Volume 04 — Tuple Reference

This volume is the machine's instruction-set reference: the normative catalogue of every tupleWave tupleAn immutable record in the wave log: offset, kind, key, payload. The unit of fact. aka tuple. (Vol. 03 §1)Volume 15 — Terminology the current runtime commits or consumes, followed by the reserved namespaces and the rules for defining new protocol families. Each entry gives the payload contract, the producer, the consumers, and the correlation discipline. Shapes are shown as reference TypeScript; field presence and meaning are the normative content.

Conventions: all entries live on the envelope of Vol. 03 §1. Entries under §3–§5 are domain.fact tuples distinguished by factType. "Key" states the required key value relative to the causing tuple.

§1. Payload data conventions

1. data of a domain.fact is a JSON object (record). Open fact types (§3.1) impose no further structure; protocol fact types (§4, §5) impose the closed shapes below.
2. Unknown additional fields in protocol payloads SHOULD be preserved by readers and MUST NOT change meaning; producers MUST NOT emit conflicting duplicates of protocol fields.
3. Grades are finite numbers in [0, 1]; producers MUST clamp before emitting.

§2. System tuples (topology protocol)

§2.1 sys.knot.defined

Seen at work Fragment 1 · The listener is added to the figure

Registers an activation knotActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology. Key: null.

payload: {
  id: string;                                    // unique knot id in this machine
  strategy: 'deterministic' | 'semantic_evaluator'; // resolved via the strategy registry
  config: KnotConfig;                            // strategy-specific, Vol. 05 §3–4
  emittedBy?: string;                            // provenance stamp when sown by a delegated emit
}

• Producer: the loaderLoaderThe component that splits an authoring pipeline into individual records and commits them as seeds. aka splitter. (Vol. 09 §6)Volume 15 — Terminology (compiled pipeline seeds) or a delegated emit template.
• Consumer: the topologyTopologyThe live set of registered activation knots and bind descriptors that the wave flows through. (Vol. 02 §5)Volume 15 — Terminology — registers the definition, eagerly builds the null-key clewClewOne per-key executor instance of a registered knot definition; parallel keys wind independent clews. (Vol. 05 §2)Volume 15 — Terminology as a configuration probe (invalid configuration fails at registration, not first use).
• An unknown strategy is a registration error (defectDefectA rejected discharge or invalid registration; the settle fails and the shell reports it. (Vol. 08 §7)Volume 15 — Terminology), not a silent skip.

§2.2 sys.descriptor.defined

Seen at work Fragment 1 · #1 · a doer is described

Registers a bind descriptorBind descriptorA bind. Woken by an activation knot, it gathers named understandings from the space, judges them, runs a service, and publishes an integration. aka descriptor, bind. (Vol. 06)Volume 15 — Terminology. Key: null. Exactly one of the two variants:

// emit descriptor
payload: { id: string; subscribesTo: string; actionConfig: { writes: string }; emittedBy?: string }
// operator bind
payload: { id: string; operator: OperatorBindConfig; emittedBy?: string }   // Vol. 06 §3

• Consumer: the topologyTopologyThe live set of registered activation knots and bind descriptors that the wave flows through. (Vol. 02 §5)Volume 15 — Terminology — constructs the executor and indexes its interests: an emit descriptorEmit descriptorThe minimal bind form: one activation, immediate truthful publication. (Vol. 06 §2)Volume 15 — Terminology under subscribesTo; an operator bindOperator bindThe full bind form: activation + demands + gates + a service crossing the membrane. (Vol. 06 §3)Volume 15 — Terminology under its activation knotActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology and every demandDemandA named binding (as:) to an activation knot whose integrated understanding the bind descriptor gathers back. The gathering face of affinity, and the second method through which understanding enters the bind. aka tendril. (Vol. 06 §3–4)Volume 15 — Terminology knot.

§2.3 sys.knot.ready

Seen at work Fragment 1 · #3 · the listener is ready

ReadinessReadinessThe state an activation knot reaches when its accumulated understanding satisfies its test; readiness is what activates bind descriptors. Readiness is reified: the topology commits it as a tuple carrying the understanding snapshot. (Vol. 02 §5, Vol. 04 §2.3)Volume 15 — Terminology reified. Key: the key of the completing fact.

payload: { knotId: string; understanding: unknown }

• Producer: the topologyTopologyThe live set of registered activation knots and bind descriptors that the wave flows through. (Vol. 02 §5)Volume 15 — Terminology, when a clewClewOne per-key executor instance of a registered knot definition; parallel keys wind independent clews. (Vol. 05 §2)Volume 15 — Terminology's test() passes — snapshot taken before reset, committed before any descriptor runs.
• Consumer: the topology's activation dispatch; every descriptor registered under knotId executes with {knotId, key, understanding}.
• Under reset: never the same clew may reify readiness repeatedly; readers fold repetition at read time (Vol. 03 §8).

§3. Open domain facts

§3.1 Pipeline facts

Seen at work Fragment 1 · #2 · a note arrives

payload: { factType: string; data: Readonly<Record<string, unknown>> }

Any fact type declared by an authoring pipelineAuthoring pipelineThe external, human-authored document describing a whole scenario. It lives outside the machine. (Vol. 09)Volume 15 — Terminology: inputs (inputs[].writes), emit-descriptor publications, operator delegated publications, head facts. Structure is fixed, when needed, by declared JSON Schemas at authoring time (Vol. 09 §7), not by the runtime.

Two conventional producer shapes exist today and are relied on by shells:

• emit descriptorEmit descriptorThe minimal bind form: one activation, immediate truthful publication. (Vol. 06 §2)Volume 15 — Terminology publication — data: { triggeredBy: [knotId], understanding } (the activating knotActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology's snapshot; never invented values);
• operator delegated publication (emit: writes) — data: { bindId, uid, result } where result is the schema-validated answer (§5.3).

§3.2 bind.rejected

An operator bindOperator bindThe full bind form: activation + demands + gates + a service crossing the membrane. (Vol. 06 §3)Volume 15 — Terminology's gateGateA predicate over the bound scope. Gates decide between emit and reject; the current form is min_grade over a named entry. (Vol. 06 §5)Volume 15 — Terminology failure. Key: the activation key.

payload: { factType: 'bind.rejected'; data: { bindId: string; reason: string } }

Produced instead of a service intentionService intentionThe machine-complete service.request an operator bind projects: instruction, scope, schema, emit declaration. (Vol. 04 §5.1)Volume 15 — Terminology when a gate fails at rendezvousRendezvousOne key lane's gathering state of an operator bind: activation flag, scope, one-shot projection latch. (Vol. 02 §4.5, Vol. 06 §4)Volume 15 — Terminology completion; the rendezvous latches as projected (one-shot, Vol. 06 §5).

§4. The winding protocol (inference.*)

The two-tact protocol by which a semantic knotActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology grows its own wound state through the world (Vol. 05 §5). All four carry knotId + uid correlation; lane is an optional mark echoed verbatim by the controllerOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology (canvasUnderstanding canvasSeveral clews winding in parallel and collecting one another's committed integrations through where clauses over lanes — cross-pollination under budgets. aka canvas. (Vol. 10 §4)Volume 15 — Terminology subscription, Vol. 05 §7).

§4.1 inference.request — winding intention

Key: the clewClewOne per-key executor instance of a registered knot definition; parallel keys wind independent clews. (Vol. 05 §2)Volume 15 — Terminology's key. Producer: semantic knotActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology (integrate: through_world). Claimed by: the inference controllerOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology.

data: {
  knotId: string;            // the projecting clew — answers route back to it
  uid: string;               // `<knotId>#<n>`
  questions: readonly string[]; // the knot's angle of perception
  state: string;             // previously integrated understanding ('' initially)
  deltas: readonly string[]; // new material to integrate
  lane?: string;
}

§4.2 inference.response — the world's integration

Key: same as request. Producer: controllerOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology. Consumer: the projecting clewClewOne per-key executor instance of a registered knot definition; parallel keys wind independent clews. (Vol. 05 §2)Volume 15 — Terminology (windsWindThe act of integrating a matched tuple into the knot's wound state. Deterministic winding completes locally; semantic winding unfolds through the world — the knot projects a winding intention and later winds the returned integration. (Vol. 05 §1, §5)Volume 15 — Terminology it as its second tact; ignores non-matching uid).

data: { knotId: string; uid: string; state: string; grade: number; lane?: string }

§4.3 inference.reasoning

The model's reasoning behind one integrationIntegrationThe understanding a bind descriptor forms and publishes as a wave tuple; received by others through binding — as an activation or as a demand — so integrations compose into higher-order understanding. (Vol. 06 §1)Volume 15 — Terminology, same correlation; emitted when non-empty. Consumer: none in the runtime (trace material; a journal knotJournal knotA never-resetting, zero-threshold knot accumulating a side record without steering control flow. (Vol. 10 §5)Volume 15 — Terminology may collect it, Vol. 10 §5).

data: { knotId: string; uid: string; reasoning: string }

§4.4 inference.failed

An expected external failure — transport error, HTTP error, timeout, unparsable output — returned as a fact so the wave settlesSettleThe runtime algorithm alternating propagation with membrane discharges until the machine settles. (Vol. 08 §3)Volume 15 — Terminology and the log records what the world answered.

data: { knotId: string; uid: string; reason: string }

Note: a failure does not clear the clewClewOne per-key executor instance of a registered knot definition; parallel keys wind independent clews. (Vol. 05 §2)Volume 15 — Terminology's INFLIGHT.UID; the clew stays awaiting its integrationIntegrationThe understanding a bind descriptor forms and publishes as a wave tuple; received by others through binding — as an activation or as a demand — so integrations compose into higher-order understanding. (Vol. 06 §1)Volume 15 — Terminology and the run surfaces the stall honestly (settled unfinishedSettled unfinishedSettled while a derivation shows an open path — unanswered intentions, a stalled clew, an open rendezvous. An honest terminal state, never masked. (Vol. 08 §7)Volume 15 — Terminology) unless topologyTopologyThe live set of registered activation knots and bind descriptors that the wave flows through. (Vol. 02 §5)Volume 15 — Terminology collects the failure deliberately. Terminality per uid: exactly one of inference.response / inference.failed is the terminal answer; inference.reasoning never terminates a uid.

§5. The operator protocol (service.*)

The protocol by which an operator bindOperator bindThe full bind form: activation + demands + gates + a service crossing the membrane. (Vol. 06 §3)Volume 15 — Terminology's judged scope crosses the membraneMembraneThe boundary where the wave meets the world: output controllers face outward, ingress faces inward. (Vol. 07)Volume 15 — Terminology and its result is published by proxy (Vol. 06 §6, Vol. 07 §4).

§5.1 service.request — service intention

Seen at work Fragment 2 · #4 · the request crosses the membrane

Key: the activation key. Producer: operator bindOperator bindThe full bind form: activation + demands + gates + a service crossing the membrane. (Vol. 06 §3)Volume 15 — Terminology. Claimed by: the serviceServiceThe function evaluated over the bound scope to produce the integration. Its kind (model instruction, deterministic function, other) is an assembly property. aka service function. (Vol. 06 §3, Vol. 08 §5)Volume 15 — Terminology controllerOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology. The intention is machine-complete: everything needed to execute and publish is inside it.

data: {
  bindId: string;
  uid: string;                       // `<bindId>#<n>`
  instruction: string;               // the operator instruction
  scope: Readonly<Record<string, unknown>>;  // the bound scope at projection
  schema?: JsonSchema;               // expected result contract (embedded, Vol. 09 §7)
  emit: EmitDeclaration;             // { writes } | { unfold } — fixed at projection
}

§5.2 service.reasoning, service.failed

Mirror §4.3/§4.4 with bindId + uid correlation:

data: { bindId: string; uid: string; reasoning: string }   // service.reasoning
data: { bindId: string; uid: string; reason: string }      // service.failed

Terminality per uid: exactly one of the delegated publication (§5.3) / service.failed; reasoning never terminates.

§5.3 Delegated publication

Seen at work Fragment 2 · #5 · the world answers, and the machine is quiet

Not a fixed fact type: the controllerOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology commits the validated answer directly under the intention's emit declaration:

• emit: { writes: T } → one domain.fact of factType T, key preserved, data: { bindId, uid, result };
• emit: { unfold: template } → an instantiated batch: sown sys.knot.defined records first, one closing sys.descriptor.defined, head facts last — each emissionEmissionA wave tuple without its offset — the form in which content is handed to the engine; the engine assigns the offset at append. (Vol. 03 §1)Volume 15 — Terminology stamped emittedBy: uid (Vol. 06 §7).

The controller fills content and never alters form; schema validation precedes publication, and a violation becomes service.failed instead.

§6. Reserved namespaces

FactType namespaces are the machine's opcode map. Current reservations:

Rules:

1. Ordinary user/shell ingressIngressThe inward half of the membrane: the edge through which external events — the world's answers among them — are committed to the wave log as fact tuples. (Vol. 07 §6)Volume 15 — Terminology MUST NOT be allowed to commit reserved-namespace facts; shells accept only declared input fact forms (a normative security rule the Cell extension restates, Vol. 12 §10).
2. A pipeline MAY read protocol facts (e.g. a journal knotJournal knotA never-resetting, zero-threshold knot accumulating a side record without steering control flow. (Vol. 10 §5)Volume 15 — Terminology collecting inference.reasoning) but MUST NOT forge them: producer classes per namespace are fixed by this volume and Vol. 12 §9's producer matrix.
3. New protocol families are introduced as domain.fact namespaces with closed payload shapes, a correlation identityCorrelation identityThe uid joining an intention with its answers (<ownerId>#<n>), plus the emittedBy provenance stamp on sown emissions. (Vol. 03 §4)Volume 15 — Terminology where asynchronous, an explicit producer class, and a collision review against this table — never as new envelope kinds unless the core is deliberately widened (Vol. 11 §2).

§7. Quick reference card

kind                    factType               producer            terminal answer for uid
────────────────────────────────────────────────────────────────────────────────────────────
sys.knot.defined            —                  loader / unfold             —
sys.descriptor.defined      —                  loader / unfold             —
sys.knot.ready              —                  topology                    —
domain.fact             <declared input>       shell ingress               —
domain.fact             <emit writes>          emit descriptor             —
domain.fact             bind.rejected          operator bind               —
domain.fact             inference.request      semantic knot          response | failed
domain.fact             inference.response     controller             (terminal)
domain.fact             inference.reasoning    controller                  —
domain.fact             inference.failed       controller             (terminal)
domain.fact             service.request        operator bind          delegated pub | failed
domain.fact             <delegated writes>     controller (proxy)     (terminal)
sys.* / domain.fact     <unfold batch>         controller (proxy)     (terminal)
domain.fact             service.reasoning      controller                  —
domain.fact             service.failed         controller             (terminal)