Spec Studio

Glossary

90 terms defined by 13 Specs.

a

  • accepted set · The set of architecturally significant units in a corpus is an owner-reviewed declaration, never derived from imports or exports; anchors are curated, never a coverage quota.

    Architecturally significant units are annotated where they are realized

  • adapter · Connects an external tool or runtime to an engine contract, such as a test runner or a TypeScript import reader.

    The engine's architectural roles each name one pattern · term.adapter

  • altitude · The scope position epic, feature, or story; epic is the ceiling, and anything above it is deferred.

    The Protocol models delivery with one enrichable Spec

  • anchor · A human-written source binding from one code location into the graph, carrying identity, an optional label, zero or more targets, and optional structure; written in one of two extracted representations, the constant form or the comment form, which feed one closed envelope. It never carries behavior, rationale, readiness, status, acceptance criteria, or delivery facts.

    Source anchors bind code without carrying intent

  • anchored · A human binding from a code, test, or oracle location to zero or more Spec IDs, or between code units for structure; it is authoritative binding and carries no intent.

    Graph claims retain their epistemic source

  • anchors subpath · The zero-dependency package subpath @libar-dev/software-delivery-protocol/anchors, exporting the id builders and the three anchor builders and nothing else; the extractor trusts it as a Protocol builder module.

    Source anchors bind code without carrying intent

  • architecturally significant unit · A code unit with exported public surface or cross-component reach whose contract or responsibility a designer or builder must understand; export status or import rank alone is insufficient. Ports, shared data shapes, pipeline stages, decision tables, catalogs, layout policies and adapters may qualify. Its anchor records component membership, a role and references to the designs it answers to. An architectural dependency is declared as uses, normally between components; a unit's own uses is optional.

    Architecturally significant units are annotated where they are realized

  • authored relation · A declared, directed Spec-to-Spec edge that records human intent.

    Specs declare typed directed relations

b

c

  • claim inheritance · An edge computed from an authored source keeps that source's claim. belongsTo derives from a Pack manifest and carries declared; anchor-derived edges carry anchored. Derivation is a mechanism, not a fourth claim.

    Graph claims retain their epistemic source

  • code anchor · An implementation-flavored binding in the impl:, api:, or component: namespace. Its optional, plural satisfies derives one anchored satisfies edge per target; its optional references derives one anchored references edge per target. It may also name one component: anchor it belongs to, a non-empty list of distinct code units it uses, and a role; a component: anchor may also name layer and context. The binding grain is the binding-grain ruling (MD-37); the structural attributes are the architectural-annotation ruling (MD-38).

    Source anchors bind code without carrying intent

  • codec · Parses, normalizes or encodes a representation while preserving the meaning owned by its contract, such as ids, carrier text, parameter input or source links.

    The engine's architectural roles each name one pattern · term.codec

  • comment form · A top-level /** … */ block in a .ts or .tsx file carrying reserved camelCase tags (@sdpAnchor, @sdpLabel, @sdpSatisfies, @sdpVerifies, @sdpModels, @sdpReferences, @sdpComponent, @sdpUses, @sdpRole, @sdpLayer, @sdpContext); @sdpAnchor <id> opens it, each tag appears at most once, prose precedes the tags, only the reserved tags are read, and comment prose authors nothing. No import is required: trust is by reserved grammar. The same id in both forms is a duplicate id. The law is the comment-form ruling (MD-36).

    Source anchors bind code without carrying intent

  • comment promotion · Source commentary that states rules other surfaces depend on is a promotion trigger: those rules promote into a standalone Spec under the promotion law, and the comment demotes to local commentary plus a Spec pointer; restating the promoted rules in the comment violates exclusive promotion.

    Spec sections carry typed detail and direct verifier semantics

  • component design · A Spec that states a component the code does not yet realize and what it is for. Its Design entries are keyed as the anchor's attributes are named: id for the planned component: anchor's own id, layer, context, uses for the components it will use, and optionally role. The keys are a convention recipes read; the Protocol closes no Design shape, and the Spec confers nothing and mints no code unit.

    Components are designed ahead of their code

  • component realization convention · A component: anchor that satisfies a Spec satisfies its seam's most-specific design Spec; that satisfies edge is the component's own realization claim. As guidance, checked by no validator: a component either satisfies its seam's design Spec or binds no Spec its members satisfy, and it never references one. Structural edges confer nothing (the architectural-annotation ruling, MD-38).

    Source anchors bind code without carrying intent

  • constant form · The top-level const initialized with a trusted builder call; the extractor reifies it statically. The decorator form remains an unextracted representation.

    Source anchors bind code without carrying intent

  • constrainedBy · A bounded Spec points to its rule, constraint, or policy Spec.

    Specs declare typed directed relations

  • content-only section · A section carries local content, while relations carry links to promoted standalone Specs.

    Spec sections carry typed detail and direct verifier semantics

  • context · An optional one-token value on a component: anchor, in the token grammar of a role, naming its bounded context; on a non-component anchor it is an envelope error.

    Source anchors bind code without carrying intent

  • contract · Owns a shared interface, data shape, closed vocabulary or public boundary that independently developed callers and providers must agree on.

    The engine's architectural roles each name one pattern · term.contract

  • curated graph · The part of the one derived graph that carries declared intent and anchored bindings, kept sparse by curation; the impact graph's inferred structure remains distinct.

    Projections fan out from one graph without becoming truth stores

  • curation · The deliberate difference between the sparse curated graph and the exhaustive code-structure surface spec:consumers.impact-graph designs; it is not drift.

    Projections fan out from one graph without becoming truth stores

d

e

f

i

k

  • kind · The true subtype that categorizes a Spec's truth and changes its required detail and validation; one of eight, each shown by its display label: behavior (Use Case / Behavior), workflow (Workflow), example (Example / Scenario), rule (Business Rule), constraint (Constraint (NFR)), model (Domain Model), decision (Decision Record), contract (Contract).

    The Protocol models delivery with one enrichable Spec

l

  • layer · An optional attribute of a component: anchor, one of edge, application, domain, adapter, or infrastructure; a value outside the set, or the attribute on a non-component anchor, is an envelope error.

    Source anchors bind code without carrying intent

m

o

p

  • Pack · An authored aggregate that groups related Specs for ideation and review while stating no system truth of its own.

    A Pack is a truth-free review aggregate

  • phase / iteration / milestone · Descriptive words a roadmap's framing may use, never an entry field, a date, a gate or an enforced sequence.

    Roadmap views read releases, baselines and phases from git and the graph

  • planned component · The component a component design names. It stays intent until a component: anchor realizes it, and that anchor satisfies the component design; the graph holds no component node before the anchor exists.

    Components are designed ahead of their code

  • plural targets · satisfies on a code anchor and verifies on a test anchor accept one ref(…) or a fresh array literal of them; verifies is non-empty. Each resolving target confers its fact as a single target does, and implemented stays a whole-Spec fact.

    Source anchors bind code without carrying intent

  • priority order · The authored member order of a Pack whose manifest states order: priority, read as its owner's advisory preference among its members; it confers nothing and sequences nothing.

    A Pack is a truth-free review aggregate

  • projection · A pure, disposable, regenerable function of the graph that produces a consumer artifact without becoming a second source of truth.

    Projections fan out from one graph without becoming truth stores

  • projection · Derives read-only presentation or generated contract content from the graph, the reader or an explicitly supplied answer. A page fragment and a complete page use the same role when both own presentation.

    The engine's architectural roles each name one pattern · term.projection

  • promotion · Moving shared or independently reviewed content into a standalone Spec of the matching kind, exclusively rather than alongside inline content.

    Spec sections carry typed detail and direct verifier semantics

  • Protocol builder binding · A builder import from the public Protocol package or its anchors subpath, or a relative import whose importer-relative resolution, including the TypeScript .js-to-.ts convention, canonicalizes to this package's ids, anchors or model/code-anchor module; consumer-local lookalike modules confer no binding authority. On the CommonJS package surface the trusted relative-module set is empty (import.meta.url is rewritten away), so relative bindings mint no anchors there while package imports stay trusted. The comment form needs no builder binding.

    Source anchors bind code without carrying intent

  • provider · A code unit that supplies an interface another unit requires; a composition selects one provider for each requirement, and a test may select another. A component design names its providers and that selection in prose, and none of them earns graph structure beyond uses.

    Components are designed ahead of their code

  • publisher · Writes or synchronizes an owned artifact set, including its path checks, replacement, recovery and clean comparison.

    The engine's architectural roles each name one pattern · term.publisher

r

  • reader · The thin typed front door that decodes graph joins and taxonomy once, returns composable data, and persists nothing.

    Projections fan out from one graph without becoming truth stores

  • reader · Answers queries over graph content, resolving or joining recorded identities and bindings without reading source files.

    The engine's architectural roles each name one pattern · term.reader

  • readiness · The author-stated design-maturity position idea, scoped, defined, or ready, checked against a structural floor.

    The Protocol models delivery with one enrichable Spec

  • realization comparison · Recipe 43, planned against realized components, which reads each component design beside the component: anchor that satisfies it, resolving members through memberOf as recipe 32 does, and lists a design no anchor satisfies yet, a layer, context or role that differs, and a uses named on one side only. It reports and refuses nothing.

    Components are designed ahead of their code

  • references · The anchored CodeNode-to-Spec edge derived from references?: readonly SpecId[] on a code anchor: this code answers to that design without claiming to realize it. The unit follows the design without realizing any of its promises, or realizes part of a Spec whose remaining promises no unit yet realizes, so a change to the design asks the code to follow. The direction is one way: a design that builds on existing code states that on its own side, by a dependsOn or refines relation to the Spec the code satisfies, never by a reference from the code. It confers no delivery fact, moves no readiness floor, and the drift alarm ignores it; a target also named in satisfies is an error. The reader reports the referencing units on the Spec's context, and blast radius traverses the edge as a binding.

    Source anchors bind code without carrying intent

  • refinement · A truth-bearing parent-child relation, distinct from the cross-cutting Pack aggregate.

    A Pack is a truth-free review aggregate

  • refines · A more precise child points to its parent; refinement is how altitude descends, and a decision that narrows one part of another decision refines it.

    Specs declare typed directed relations

  • release · A tagged set surfaced as a git-tag projection.

    Roadmap views read releases, baselines and phases from git and the graph

  • roadmap · A Pack whose manifest states a priority order, read with what each entry still needs next; its order is an advisory preference, never a schedule or a gate.

    Roadmap views read releases, baselines and phases from git and the graph

  • role · An optional one-token value on a code anchor, lowercase kebab and never normalized, naming the architectural pattern the unit plays; a corpus-owned vocabulary whose taxonomy the census renders with counts, checked against no list.

    Source anchors bind code without carrying intent

s

t

u

  • untrusted builder · A constant-form builder call whose import is no Protocol builder binding: it mints nothing and reports nothing, because a source file that never bound to the Protocol is not authoring drift to report.

    Source anchors bind code without carrying intent

v

Composing (0)

Composing needs the script.