proto.computer / companion doc

build world grammar

the build world should feel like a tycoon kit, not a generic mesh editor. authors place a small semantic kit; the compiler derives most of the machinery; runtime animates the same scene basis. this rebuild makes the cross-sections explicit: how a face fronts source composition, why anchors are orb cutaways, how authored pieces expand into derived machinery, and how run mode overlays the same set.

build world = authored pieces + derived structure + runtime overlays
source → binding → port → face → gate → switch → chamber → anchor orb → track / screen / dock
author core: zone · face · anchor · track · dock · screen derived: conduit · gate · switch · chamber · bridge runtime-only: token · pulse · overlay · beacon

cross-section viewer

one world, five cuts. top plan is for spatial intuition; boundary and orb cuts are where the semantic membrane becomes visible.

west / faces center / anchors north / tracks south / docks east / screens face face face anchor anchor anchor track dock dock screen screen screen default districting: ingress west, registry center, lifecycle north, actions south, readout east.
top plan gives a fast tycoon legibility. the world is not “random 3d app furniture”; districts carry semantic weight. faces cluster at the shell, anchors hold the center, tracks sit above as lifecycle, docks below as action, and screens to the east as readout.
source rack qr / url http / json sheet / file binding auth parser matcher admit port typed slot face gate admission switch chamber attempt / decide commit boundary anchor orb track socket dock / screen basic mode may hide the middle pieces, but the compiled scene still owns gate, switch, and chamber semantics.
this is the clean cut through the build world. the face is not the whole boundary story; it fronts the source/binding/port stack. the orb is not just decoration; it is where resident meaning lives.
anchor anatomy: the placeable object is the semantic membrane, not just a schema icon proto bay keyspace resident epis live here intake bay bind rule socket birth rule socket relation bridge screen / dock refs effect hooks track socket / lawful motion projection refs / view selectors the orb implies a livable interior: residents, keys, lookup/birth semantics, and sockets for motion, relation, and readout.
the builder only needs one anchor piece, but the cutaway keeps its derivation visible. this lets the orb carry epistemic weight: it is a membrane, a registry, and a socketed hub all at once.
authored derived runtime zone face anchor track dock screen conduit gate switch chamber bridge token / epi pulse / datum overlay / selection beacon / lag / fault builder places the semantic nouns; compiler derives most of the airport-schematic; runtime animates the same set.
this is the core build-world thesis in one cut: place meaning, derive machinery, animate truth. the editor should not make authors hand-place every conduit elbow unless they explicitly want advanced wiring mode.
lag beacon run mode reuses the same geometry; it adds pulses, resident tokens, occupancy, backlog, lag, fault, and selection overlays.
the runtime overlay should feel like a living film of the same authored set. no editor ontology, no separate dashboard ontology, no bait-and-switch. build and run share one spatial basis.
boundary / faces / pulses anchors / durable ontology tracks / lifecycle docks / action screens / readout fault / urgency

minimum kit

family authored? semantic binding cross-section role default silhouette
zone / plinthyesworld districtgives districts a floorplan and layered meaningdeck slab / shell segment
faceyesinterface + source + binding reffront door for source composition; semantic aperture on the shellportal / kiosk / arch
anchoryesprotoplaceable membrane where epis can bind or be bornglowing orb / archive core
trackyesprocess + statuseslawful motion over timerail / loop / halo path
dockyeseffectoutbound obligation stationberth / mast / handoff desk
screenyesprojection / viewread surface into the worldglass slab / lens / board wall
conduitderived by defaultroute family / lineage pathmakes flow and relation physically legiblepipe / beam / luminous stream
gatederived by defaultadmission / auth / authzchecks whether caught material may count herescanner arch / customs frame
switchderived by defaultruleset family / route fanoutshows local interpretation horizonjunction diamond / sorting table
chamberderived by defaultattempt / decide / commit cellwhere semantic possibility becomes durable factvault / kiln / workcell
bridgederived or authoreddeclared relation / lookup pathconnects anchors via explicit relation semanticstether / walkway / ring bridge
token / pulse / overlay / beaconruntime-onlylive facts onlyanimates presence, movement, lag, fault, and focusparticle / glow wash / alert spire

source composing in build mode

the user should not have to think “i am writing an http listener with custom auth plumbing” unless they want advanced mode. but the world still needs a place for those semantics: 

basic mode
  place face
  bind source
  choose matcher preset
  choose proto targets
  choose effects / views

advanced mode
  inspect ports
  inspect auth and parser
  edit admit policy
  edit bind / birth rules
  inspect outbound policy

so the face remains the top-level authored noun, while the binding rack, ports, gate, and switch can be derived or expanded on demand. same grammar, different altitude.

inbound / outbound symmetry

inbound cut
  source
    -> binding
    -> port
    -> face
    -> gate
    -> switch
    -> chamber
    -> anchor orb

outbound cut
  obligation
    -> dock
    -> chamber
    -> port
    -> binding
    -> target system

outbound should therefore look like a cousin of inbound, not a totally separate sub-editor. same world, reversed causality.

snap grammar explorer

choose a family to see its natural neighbors. this is intentionally toy-like: place stations and rails, not arbitrary meshes.

face gate switch chamber anchor bridge track dock screen
snap rules are semantic, not arbitrary. the highlighted family shows the most natural neighbors; advanced mode can still expose derived pieces directly when you need to wire the airport by hand. 
verbs = place · bind · connect · group · orient · layer · lens · skin · pin

snap(face)   -> conduit | gate | screen
snap(anchor) -> chamber | track | bridge | screen
snap(track)  -> anchor | track.stop | screen
snap(dock)   -> chamber | anchor | conduit
snap(screen) -> face | anchor | track

compile recipe

compile_world_to_scene(world_spec) =
  place_zones(world)
  + place_faces(interfaces)
  + place_anchors(protos)
  + place_tracks(processes)
  + place_docks(effects)
  + place_screens(projections)
  + derive_bridges(relations, lookups)
  + derive_flow(routes, gates, switches, chambers)
  + attach_lenses(filters, inspectors)
  + attach_runtime_overlays(epi, datum, lag, error, selection)

the compiler’s job is to preserve semantic breadcrumbs while reducing author toil. it should never invent a second ontology.

shape language

durable ontology  -> circles, rings, anchored cores
boundary          -> arches, portals, docks, counters
flow              -> lines, tubes, beams, moving pulses
thresholds        -> gates, scanners, customs frames
decision fanout   -> diamonds, switch tables, splitters
read surfaces     -> slabs, lenses, walls, observatories
alert / obligation-> beacons, flares, amber towers

the point is guessability. even before labels, a user should infer that circles are durable things, rails are workflows, and screens are read surfaces.

auto-layout defaults

default districts
  west   = faces / ingress
  center = anchors / registry
  north  = tracks / lifecycle
  east   = screens / readout
  south  = docks / effects

sizing heuristics
  proto size        ~ log(entity_count)
  bridge thickness  ~ relation fanout
  conduit thickness ~ recent throughput
  chamber radius    ~ concurrency budget
  track length      ~ number of statuses
  beacon height     ~ urgency / sla pressure

aesthetics bible

mood

miniature nocturne operations world. half airport, half motherboard, half toy city. yes, still three halves.

camera

3/4 orthographic or long-lens perspective. slow drift, no twitch. selection reveals local causality, not michael bay.

material language

obsidian plinths, smoked glass, satin gunmetal, luminous filaments, resin glow inside anchors and tracks.

motion

steady pulses, constrained couriers, subtle occupancy bobbing, rare but bright commit flashes, almost no idle chaos.

scene zero — compact credit ops world

faces whatsapp email docs sheet rows anchors customer credit_request credit tracks origination underwriting servicing screens + docks pipeline board customer lens send whatsapp / export scene zero should already stress every family: inbound boundary, orb births, tracks, docks, screens, and the split between request and active credit.
this replaces the missing external art-board dependency with a self-contained concept panel. start with a credit ops world bc it is semantically rich without becoming a zoo.