Glossary

Purpose: Canonical definitions for terms used in maintained Manifesto docs. Rule: If a term is used differently elsewhere, the current maintained package docs and living specs win over historical archive usage. Current Model: This glossary follows the current hard-cut surface: Core/Host as canonical substrate layers, SDK as the activation-first public runtime, and Lineage/Governance as explicit decorator protocols.

---

How to Use This Glossary

• Terms are listed alphabetically.
• Each term includes:
  • Definition: What it means in the current project.
  • Not to be confused with: Common misconceptions or historical meanings.
  • See also: Related current terms.
• Historical or retired meanings are marked explicitly.

---

A

Actor

Definition: An entity that originates governed change requests. Actors matter on the governed path, where proposals, approval, and sealed history are tracked explicitly.

Kinds: human, agent, system

Not to be confused with:

• Actor Model - unrelated concurrency concept
• User - Actor is broader and includes non-human callers

See also: Authority, Governance, Proposal

---

ActionRef

Definition: A type-safe reference to an action. In the v5 app-facing runtime, callers use app.action.<name> handles; low-level extension tooling may still expose action references for simulation and debugging.

Not to be confused with:

• Raw string action names - string names are metadata, not the canonical submit surface
• BoundAction - ActionRef identifies an action; bound actions carry candidate input and can expose an advanced intent() escape hatch

See also: FieldRef, ComputedRef, Intent

---

Authority

Definition: An entity that judges proposals and issues legitimacy decisions. Authority decides; it does not execute effects or apply state.

Kinds: auto, human, policy, tribunal

Not to be confused with:

• Authentication - identity verification
• Permission - static access control

See also: Actor, Decision Record, Governance

---

B

Bridge

Definition: Historical term for application-side translation or glue logic between external events and domain intents. In the current hard-cut model there is no standalone maintained Bridge package in the public runtime story.

Not to be confused with:

• Host - Host executes requirements and applies patches
• SDK - SDK owns the public activation/runtime surface

See also: Intent, Projection, SourceEvent

---

C

Computed

Definition: Derived values calculated from current snapshot data under the schema. Computed values are not persisted as domain state; they are recalculated from the canonical substrate and may be filtered from projected public reads.

Not to be confused with:

• Cached values - Computed has no caching guarantee in the public contract
• Stored state - Computed is not authored through patches as domain state

See also: ComputedRef, ExprNode, Snapshot

---

ComputedRef

Definition: A type-safe reference to a computed node on the typed domain refs surface, such as refs.computed.*. ComputedRef.name is the stable public identifier used by SDK introspection and typed access.

Not to be confused with:

• Computed values themselves - ComputedRef identifies the node; it is not the evaluated value
• FieldRef - state field reference, not a computed reference

See also: ActionRef, Computed, FieldRef

---

Compiler

Definition: The package/layer that compiles MEL into DomainSchema and related artifacts consumed by Core and SDK. In the current model it also produces SchemaGraph extraction metadata used by SDK introspection.

Not to be confused with:

• Core - Core computes over compiled schema but does not compile MEL
• SDK - SDK consumes compiled schema and graph metadata but does not own MEL lowering

See also: DomainModule, DomainSchema

---

Core

Definition: The pure computation layer that evaluates semantic meaning. Core performs deterministic semantic transitions with no IO, wall-clock access, or effect execution.

Mantra: "Core computes. Host executes. These concerns never mix."

Not to be confused with:

• Host - Host owns execution and requirement fulfillment
• Runtime - Core is only the pure semantic layer

See also: Host, Semantic Space, Snapshot

---

Context

Definition: The captured external environment supplied to one Core computation. Context is explicit JSON-serializable data, not a provider, callback, promise, mutable object, or IO handle.

Key distinction: Snapshot is schema-driven existence information that persists across computations. Context is external environment captured for the current transition attempt and must be supplied again for deterministic replay.

See also: Core, Snapshot, Coordinate Calculation

---

Coordinate

Definition: A single point in semantic space, represented by snapshot state. At the Core/Host boundary this means the canonical snapshot substrate. At the SDK boundary applications usually observe a projected public read model derived from that same coordinate.

Key insight: Manifesto treats state as a position to navigate, not just mutable data to edit.

See also: Semantic Space, Snapshot

---

Coordinate Calculation

Definition: The process by which Core determines the next valid position in semantic space from the current position and an intent.

Equation: compute(schema, snapshot, intent, context) -> ComputeResult

Determinism is over the full schema + snapshot + intent + context tuple.

See also: Coordinate, Context, Core

---

D

Decision Record

Definition: A governance-owned immutable audit record created when authority issues a terminal decision on a proposal.

Key properties:

• Created for terminal legitimacy decisions
• Immutable once recorded
• Carries the decision outcome and any approved scope when applicable

See also: Authority, Governance, Proposal

---

DomainModule

Definition: A compiler tooling artifact returned by additive seams such as compileMelModule(). It carries the compiled DomainSchema plus compiler-owned helper artifacts such as SchemaGraph and tooling-only sidecars including AnnotationIndex and SourceMapIndex.

Key properties:

• Contains schema, graph, annotations, and sourceMap
• Exists for tooling, inspection, and external consumers
• Is not accepted by runtime seams such as createManifesto(); runtime consumes DomainSchema only

See also: Compiler, DomainSchema

---

SourceMapIndex

Definition: A compiler-owned tooling sidecar that records declaration-level MEL source spans for emitted schema targets.

Key properties:

• Keyed to the emitted schema by schemaHash and to the physical source text by sourceHash
• Carries explicit coordinate encoding via coordinateUnit and emission identity via emissionFingerprint
• Remains outside DomainSchema, SchemaGraph, and runtime input seams

See also: Compiler, DomainModule

---

DomainSchema

Definition: The compiled domain specification understood by Core. It defines state fields, computed fields, actions, and flow/evaluation structure in schema form.

See also: DomainModule, Flow, Intent

---

E

Effect

Definition: A declaration of external work that Host must fulfill. Effects are declared by Core and executed by Host; Core never performs IO itself.

Key properties:

• Declared, not executed, by Core
• Produces requirements for Host fulfillment
• Results re-enter the system through patches/system deltas, not hidden return channels

Not to be confused with:

• Side effect - Effects are explicit protocol artifacts
• Action - Actions may declare effects, but are not effects themselves

See also: Host, Requirement

---

ExprNode

Definition: A node in the pure expression language evaluated by Core.

Categories:

• Literals: string, number, boolean, null
• Comparisons: eq, ne, gt, lt, gte, lte
• Logical: and, or, not
• Arithmetic: add, sub, mul, div
• Collection: filter, map, find, length
• Object/value access: get, merge

See also: Computed, FlowNode

---

F

FieldRef

Definition: A type-safe reference to a state field on the typed domain refs surface, such as refs.state.*. FieldRef.name is the stable public identifier for the referenced top-level state node.

Not to be confused with:

• String paths - user-facing APIs should not require string paths as the canonical surface
• ComputedRef - computed node reference, not state field reference

See also: ActionRef, ComputedRef

---

Flow

Definition: A declarative computation sequence evaluated by Core. A flow may emit patches, requirements, halts, or failures as values in the transition contract.

Key properties:

• Must be re-entry safe
• Is evaluated from the beginning on each compute cycle
• Encodes progress through snapshot state, not hidden execution context

Not to be confused with:

• Workflow engine - Flow is a smaller deterministic primitive
• Function call stack - Flow is declarative protocol structure

See also: Effect, FlowNode, Patch

---

FlowNode

Definition: A node in the flow DSL describing declarative state transition behavior.

Kinds:

• seq - Sequential execution
• if - Conditional branching
• patch - State mutation declaration
• effect - Requirement declaration
• call - Invoke another flow
• halt - Stop without error
• fail - Stop with failure encoded as value

See also: ExprNode, Flow

---

G

Governance

Definition: The decorator/runtime layer that owns proposal legitimacy, approval flow, decision records, and governed execution. In the current public assembly it is added with withGovernance() on top of lineage.

Not to be confused with:

• Host - Host executes approved work; governance does not execute
• Lineage - Lineage owns continuity/history, not legitimacy decisions

See also: Authority, Lineage, Lineage Record, Proposal

---

H

Host

Definition: The execution layer that fulfills requirements and applies patches/system deltas. Host bridges pure Core computation to external IO and persistence boundaries without owning domain meaning.

Key properties:

• Executes requirements declared by Core
• Applies patches to canonical snapshots
• Follows protocol rather than making semantic decisions

Not to be confused with:

• Server - Host can run in many environments
• Governance - Host executes; governance judges

See also: Core, Effect, Requirement

---

I

Intent

Definition: A command requesting a domain action. In v5, raw Intent construction is an advanced protocol escape hatch exposed from BoundAction.intent() and extension tooling; normal app code submits through action.<name>.

Related low-level forms:

• IntentBody - command body (type + input)
• IntentInstance - governance-oriented low-level object carrying extra provenance/materialization context

Not to be confused with:

• Event - Intent requests change; events describe facts
• ActionRef - ActionRef identifies an action; Intent requests that it run

See also: ActionRef, Governance, Proposal

---

L

Lineage

Definition: The continuity layer and DAG of sealed lineage records. In the current public assembly it is added with withLineage() and owns sealing, restore, branch/head queries, and stored record lookup.

Key properties:

• Append-only continuity/history
• Branch and head semantics are lineage-owned
• Lineage-only environments can create sealed records without proposals
• getWorldSnapshot(worldId) reads stored sealed canonical substrate

Not to be confused with:

• Governance - governance owns legitimacy; lineage owns continuity
• Current visible snapshot - lineage also stores sealed historical records

See also: Governance, Lineage Record, Snapshot

Lineage Record

Definition: An immutable sealed record in lineage history. The current public TypeScript name is WorldRecord, but maintained explanatory docs call the concept a lineage record to avoid treating retired world-facade packaging as current architecture.

Key properties:

• Immutable once sealed
• Participates in lineage history and branch/head structure
• May exist with or without proposal provenance depending on whether governance is active
• Governed composition is expressed through createManifesto() -> withLineage() -> withGovernance() -> activate()

Not to be confused with:

• Retired top-level facade package - no longer the current public entry
• Snapshot - snapshot is the runtime coordinate; a lineage record is the sealed historical record of such a coordinate

See also: Governance, Lineage, Snapshot

---

P

Patch

Definition: A single atomic state mutation instruction. Patches are the only way domain state changes are expressed in the semantic transition model.

Operations: set, unset, merge

Not to be confused with:

• Diff - a diff describes change after the fact; a patch prescribes change
• Mutable assignment - patches are declarative protocol operations

See also: Flow, Snapshot

---

Projection

Definition: A derived read model produced from canonical substrate. In the current maintained docs, the primary projection is the SDK Snapshot returned by snapshot(), which hides canonical-only substrate while preserving application-facing meaning.

Not to be confused with:

• Historical Bridge/App event routing usage - older docs sometimes used "projection" for event-to-intent translation
• Canonical substrate - projection is a derived public view, not the full runtime state

See also: Snapshot, SourceEvent

---

Proposal

Definition: A governance-owned accountability record wrapping an intent with submission and legitimacy context. Proposals exist on governed runtimes; they are not part of the base SDK or lineage-only execution path.

Key properties:

• Tracks who requested what and under which legitimacy context
• Advances through governance-controlled judgment/execution states
• Produces decision visibility and auditability on the governed path

Not to be confused with:

• Intent - the requested action itself
• Lineage Record - a sealed historical outcome, not the request record

See also: Authority, Decision Record, Intent

---

R

Requirement

Definition: A pending effect execution declaration awaiting Host fulfillment. Requirements live in canonical snapshot.system.pendingRequirements and are intentionally excluded from the projected SDK snapshot() surface.

Key properties:

• Deterministically identified
• Owned by the canonical execution substrate
• Fulfilled by Host, not by Core or SDK projections

See also: Effect, Host, Snapshot

---

S

Semantic Space

Definition: The mathematical space defined by a DomainSchema. Schema defines dimensions and constraints, snapshots are coordinates in that space, and intents ask for valid movement.

The foundational model:

• Schema = space definition
• Snapshot = coordinate
• Intent = navigation command
• Computation = coordinate calculation

Key insight: Manifesto asks for the next valid semantic position, not just how to mutate arbitrary data.

See also: Coordinate, DomainSchema, Snapshot

---

Snapshot

Definition: The complete state coordinate of a domain at a point in time. At the Core/Host boundary this means the full canonical substrate. At the SDK/application boundary snapshot() returns a projected public read model derived from that substrate, while inspect.canonicalSnapshot() exposes the current canonical runtime substrate directly.

Structure:

• state - domain state
• computed - derived values
• system - projected reads expose status and lastError; canonical substrate also carries pendingRequirements and currentAction
• meta - projected reads expose schemaHash; canonical substrate also carries version, timestamp, and randomSeed
• input - canonical-only transient action input
• namespaces - canonical platform/runtime/tooling state such as Host and MEL bookkeeping

Current contract note: accumulated system.errors is not part of the current canonical snapshot contract.

Not to be confused with:

• State - snapshot emphasizes immutable whole-truth state, not mutable variables
• Lineage Record - a sealed historical coordinate, not just the current visible runtime read

See also: Coordinate, Lineage Record, Projection

---

SourceEvent

Definition: Historical term from older Bridge/App documents for an external signal that could be translated into an intent. It is not a primary term in the current maintained SDK/Lineage/Governance package surface.

Not to be confused with:

• Intent - current public command object
• Event payloads on runtime telemetry channels - those are runtime events, not this older routing term

See also: Bridge, Intent, Projection

---

Quick Reference Table

Term	One-Liner
ActionRef	Typed action identifier used by runtime handles and extension tooling
Actor	Entity that originates governed change requests
Authority	Entity that judges proposals
Bridge	Historical translation/glue term, not a current package
Computed	Derived value from snapshot state
ComputedRef	Typed computed identifier on refs.computed.*
Compiler	MEL-to-schema and graph extraction layer
Core	Pure semantic computation layer
Coordinate	A point in semantic space
Coordinate Calculation	Finding the next valid semantic position
Decision Record	Immutable audit of a terminal legitimacy decision
DomainModule	Compiler output carrying compiled domain artifacts
DomainSchema	Compiled domain specification understood by Core
Effect	Declaration of external work
ExprNode	Pure expression node
FieldRef	Typed state-field identifier on refs.state.*
Flow	Declarative transition sequence
FlowNode	Node in the flow DSL
Governance	Legitimacy/approval decorator layer
Host	Execution and fulfillment layer
Intent	Canonical public command object
Lineage	Continuity layer and sealed-record DAG
Lineage Record	Immutable sealed point in lineage history
Patch	Atomic mutation instruction
Projection	Derived public read model from canonical substrate
Proposal	Governance-owned accountability record
Requirement	Pending effect execution declaration
Semantic Space	Mathematical space defined by DomainSchema
Snapshot	Complete state coordinate at a point in time
SourceEvent	Historical event-routing term

---

End of Glossary