proto.computer / draft root

section 1 — core abstractions

this is the tightened starting point. the small semantic spine stays small, but the boundary before it is now explicit: sources, bindings, ports, and faces catch outside material; then protos act as semantic membranes where epis can be bound or born. the build world, runtime, and viewer all derive from that same split.

companions: abstraction matrix · build world grammar · section 2 / finexa · section 3 / rust dsl + runtime algebra · compiler ir spec · proto schema matrix

1.0 thesis

the canonical semantic spine per admitted route is still:

d → ρ → ι → ℓ → ω → ψ

d = admitted datum, not arbitrary bytes ρ = chosen path, still pre-semantic proto = glowing semantic membrane epi = resident instance the world recognizes

source → binding → port → face → d → ρ → ι → ℓ → ω → ψ

the new move is not to bloat the kernel. it is to stop cheating about what happens before d and at the moment an outside thing becomes a world-recognized thing. the semantic story still begins at admitted datum; the docs now also show how admission and proto crossing work.

1.1 the boundary before the spine

the missing prelude

outside material
  → caught at a deployed port
  → gated / parsed / normalized by a face
  → admitted as datum d
  → routed toward candidate business meaning

this is why a webhook payload, a csv row, or a human desk entry is not yet business truth. it is merely something the world caught.

the missing crossing

d
  + face rules
  + bindings
  + proto lookup
  → bind epi | birth epi | reject | quarantine

this is why a proto is more than a schema. it is the lawful membrane that decides whether the outside thing becomes one of ours.

port catch ≠ semantic admission ≠ epi birth

a caught whatsapp webhook may be noise, the wrong conversation, a retry, a duplicate, a delivery receipt, or a genuine origination step. only face rules and proto bindings decide which one.

1.2 source composing

source composing is the rule that the world boundary is itself authored, not hand-waved as infra sludge. a source can be an api, a file drop, a third-party product, a human desk, or another proto.computer world. a face is the semantic aperture where those sources are made legible here.

pattern	what it means	why it matters
many ports → one face	the same business face may be fed by a webhook, a poller, and a human desk.	deployment changes without changing business meaning.
one face → many route families	one whatsapp face may carry start events, flow submits, doc uploads, and delivery receipts.	catching a message is not the same as knowing what it means.
many faces → one proto bay	qr entry, form submit, docs upload, and operator desk may all converge on one `credit_request` proto.	the durable kind stays singular while the ingress topology stays plural.
one datum → many candidate routes	the same admitted thing can be eligible for several legal paths.	routing is explicit and replayable instead of hidden in ad hoc handlers.
outbound symmetry	what goes out also travels through effect faces, ports, auth, and delivery rules.	sending is just the reverse boundary story, not magical side-channel glue.

authoring view

implement_face
  = source selection
  + port shape
  + auth / gate policy
  + parse / normalize
  + field bindings
  + proto lookup rules
  + reject / quarantine policy

symmetric outbound view

obligation ο
  → dock / effect face
  → deployment binding
  → outbound port
  → outside source / system
  → delivery receipt or retry

“implementing an api” in proto.computer should therefore mean: declare the source, the port, the face, the rules, the bindings, and the reject path. if any of that lives only in code folklore, the world spec is still incomplete.

1.3 the proto boundary and why the anchor is a glowing orb

the orb glows because it is the place where outside ambiguity condenses into inside identity.

what a proto really is

a proto is not just “the schema for a record type.” it is the lawful boundary of a durable kind. it declares what keys count, what relations are admissible, what minimal shape is required for existence, and what bindings are allowed to claim that an outside thing is one of these.

proto = kind law + keyspace + relation law + intake bays

what an epi really is

an epi is the resident instance inside that boundary. it is the thing the world can point at, move through processes, relate to other things, and project into views. its history is grounded by durable record ℓ, but its identity is legible at the proto boundary.

commitχ may birth, bind, or update epis while writing durable record ℓ

orb part	formal meaning	viewer intuition
shell / membrane	the proto boundary: what counts as this kind here.	the orb surface glows because it is a semantic event horizon.
intake bays	the local composition points where faces, bindings, and rules converge.	small ports or ringed sockets around the orb.
matcher ring	lookup, dedupe, relation binding, and birth rules.	a rotating inner halo deciding “is this already one of ours?”
core	the current epi population and selected resident.	a warm nucleus or clustered lights inside the shell.
bridges	declared relations to other protos.	tethers between glowing orbs.
halo / pressure	runtime overlays: obligations, lag, selection, dwell, faults.	extra glow, warning rings, and occupancy bloom.

this is also why the system feels fractal. a source feeding one orb may itself be another world with its own faces and orbs. the grammar repeats, just at a different boundary.

1.4 formal operators

under κ, χ, μ, ν and σ:

admitχ   : (χ, source_material, face_binding) -> d*
routeχ   : (χ, d) -> ρ*
spawnχ   : (χ, d, ρ) -> α
placeχ   : (χ, α) -> λ
decideκ  : (κ, s, ρ, d) -> ι*
commitχ  : (χ, s, α, λ, ρ, d, ι*) -> (ξ, ℓ+, ο*)
measureμ : (μ, ℓ*) -> ω
renderν  : (ν, σ, ω, live) -> ψ

admitχ owns auth, gating, parsing, normalization, and quarantine at a face. d means admitted datum, not raw source bytes. semantics still begins at decideκ.

commitχ is the place where legal proposals become durable facts. in builder language, that is also where the affected proto orb gains, links, or mutates an epi.

minimal chain: admit → route → decide → commit → measure → render

1.5 boundary vocabulary

term	plain meaning	job in the system
`source`	where outside material originates.	whatsapp, trello, a bank sheet, a human desk, another world, a browser page.
`port`	the deployed contact point.	http endpoint, webhook url, file watcher, poller, browser action, manual intake desk.
`binding`	the mapping between deployed shape and semantic intent.	auth rules, headers, field names, ids, key precedence, relation resolution.
`face`	the semantic aperture on the world boundary.	admits outside material as datums and routes them toward business meaning.
`ruleset`	the local transformation and admission logic of a face.	parse, normalize, transform, match, reject, quarantine.
`proto`	the durable kind boundary.	declares what counts as a customer, request, loan, payment, document, and so on.
`epi`	the concrete resident instance under a proto.	one actual request, payment, customer, or case recognized by the world.
`bay`	the local composition chamber on or around a proto.	the point where multiple faces and bindings converge on bind-or-birth logic.

these are ontology-and-boundary nouns. they sit orthogonally to the symbolic spine. the symbolic spine explains motion; this vocabulary explains where motion touches the world.

1.6 symbol glossary

symbol	plain name	owned by	role
`κ`	law	compiled world	semantic kernel. given a snapshot, a chosen path, and an admitted datum, it yields legal proposals.
`χ`	machinery	compiled + live world	runtime execution. admits, routes, spawns attempts, places lanes, commits, retries, replays, and discharges obligations.
`μ`	readout rules	compiled + live world	derives projections, lineage, windows, metrics, and inspectors from durable record.
`ν`	staging	compiled + live world	maps the set plus readout plus live condition into a legible viewer world.
`σ`	set	compiled world	stable placed scene basis. build and run share it.
`d`	admitted datum	face → χ	outside material after boundary gating and normalization.
`ρ`	path	χ → κ	a chosen interpretation path for one admitted route.
`ι`	proposal	κ → χ	a legal intent bundle emitted by the semantic kernel. proposal is not yet fact.
`α`	attempt	χ	one concrete runtime responsibility created for one admitted route.
`λ`	lane	χ	the local serial order and commit domain in which an attempt is executed.
`ξ`	receipt	χ	the runtime summary of commit outcome.
`ℓ`	record	χ → μ	durable committed trace. this is the authoritative substrate for observation.
`ο`	obligation	χ	a durable promise owed by the world to the outside, typically discharged by outbox delivery.
`ω`	readout	μ → ν	derived state produced from durable record.
`ψ`	picture	ν	the viewer world: staged appearance, not the record itself.

1.7 strata

law

defines what changes would be legal under a chosen path and snapshot. it does not catch ports, schedule retries, or deliver effects.

machinery

owns admission, routing, attempt materialization, lane placement, commit, replay, and obligation discharge.

readout

turns durable record into projections, metrics, lineage, windows, and inspectors.

staging

turns set plus readout plus live condition into one shared picture. it controls camera, overlays, lod, and emphasis.

set

the stable placed world. editor and runtime share the same scene basis instead of inventing different ontologies.

protos, epis, faces, bays, and bindings are not extra strata. they are the ontology and boundary objects that the strata operate over.

1.8 three zoom levels

authored world

what the builder declares: sources, faces, protos, processes, effects, projections, scene layout, and the boundary rules that connect them.

compiled world

what the machine actually is: law, machinery, readout, staging, set; plus the explicit face, port, and proto-boundary logic they operate over.

live world

what operations handle: attempts, lanes, receipts, durable record, obligations, occupied orb bays, backlog, lag, and viewer overlays.

author the constitution → compile the machine → instantiate the company

or, at the boundary zoom: author the ports → admit the datum → cross the proto → move the world

1.9 invariants

port catch is not semantic admission. raw source material does not count as d until a face admits it.
admitted datum is not yet an epi. d still has to cross a proto boundary via bindings and lookup rules.
routing is pre-semantic. ρ is a selected interpretation path, not yet business truth.
law proposes; machinery commits. κ emits ι*. only χ can make durable ℓ.
proto crossing is explicit. the world spec must say how datums bind or birth epis, not bury that in ambient handler code.
record is the observational substrate. μ derives ω from ℓ, not from transient in-flight state alone.
picture is not the record. ψ may be selective, aggregated, or cinematic without changing the truth.
the same set is shared by build and run. σ is authored once and animated later.
one admitted route yields one attempt and one local commit boundary. fanout is represented as multiple admitted routes, not one giant transaction blob.
obligations are durable. anything the world owes the outside after commit is represented as ο.
outbound uses the same honesty as inbound. sending is also face + binding + port + receipt, not an invisible afterthought.
the system is fractal. a source may itself be another world; the same boundary grammar applies recursively.

1.10 viewer-world intuition

ψ = renderν(σ, ω, live)

the viewer world should make the boundary legible, not hide it. you should be able to see where a pulse entered, which face admitted it, which orb bay received it, whether it bound an existing resident or birthed a new one, which track it moved through, and what obligations it left behind.

build truth mode

place faces, orb anchors, tracks, docks, screens, and the set that binds them.

boundary truth mode

inspect ports, rulesets, bindings, quarantine paths, orb bays, and identity lookups.

run truth mode

watch attempts, records, obligations, lag, dwell, and causal cones animate the same set.

author the boundary, not just the middle.
the orb is where the world starts to mean what it sees.

1.11 summary

if you want the smallest vocabulary that is still correct, use this:

boundary: source / port / binding / face / proto / epi compiled: law / machinery / readout / staging / set spine: admitted datum / path / proposal / record / readout / picture runtime: attempt / lane / receipt / obligation

everything later in the spec should name which zoom level it is acting on, which boundary object it consumes or produces, and which proto orb it is trying to enter.