@dtmd/temper 0.0.4 → 0.0.7

package/dist/src/contract.js

@@ -1,13 +1,12 @@
 /**
- * Contracts — clauses and requirements as typed values (`specs/architecture/10-contracts.md`).
+ * Contracts — clauses and requirements as typed values.
  * A clause is `predicate · severity · guidance · cite`; a requirement is
- * `means · kind · required · clauses? · verifiedBy?`. Both erase to compiled data
- * at the seam (`20-surface.md`): the author composes typed objects, the engine
+ * `prose · kind · required · clauses? · verifiedBy?`. Both erase to compiled data
+ * at the seam: the author composes typed objects, the engine
  * consumes their rows. The predicate vocabulary is the closed algebra — a clause
- * outside it is a squiggle, not a runtime rejection (`10-contracts.md`, the two
- * walls).
+ * outside it is a squiggle, not a runtime rejection.
  */
-// Node-scope predicates (`10-contracts.md`, "The predicate algebra").
+// Node-scope predicates.
 /** A field or marker is present. */
 export const required = (field) => ({ key: "required", field });
 /** The field's parsed scalar type is as declared. */
@@ -36,8 +35,35 @@ export const deny = (field, values) => ({
 export const requireSections = () => ({ key: "require_sections" });
 /** The member's name matches its directory. */
 export const nameMatchesDir = () => ({ key: "name-matches-dir" });
-// Node-set/edge-scope predicates (`10-contracts.md`, "Judged at the node-set
-// scope" / "Judged at the edge scope") — a requirement's set-scope demands ride
+/** Names are unique within the artifact kind (a scope-wide identity collision). */
+export const uniqueName = () => ({ key: "unique-name" });
+/**
+ * The named field may be present — always satisfied, recording the key as part of a
+ * declared (closed) schema. `dependency-exists` has no constructor: the engine holds
+ * it back absent a decidable reference syntax, so a hand-authored clause would fail
+ * admissibility.
+ */
+export const optional = (field) => ({ key: "optional", field });
+/** The field's numeric value lies within the inclusive `[min, max]` bound. */
+export const range = (field, min, max) => ({
+    key: "range",
+    field,
+    range: { min, max },
+});
+/** The field's value is one of `values`. Spelled `enumOf` — `enum` is a reserved word. */
+export const enumOf = (field, values) => ({
+    key: "enum",
+    field,
+    values,
+});
+/** The named body marker is defined (e.g. `disable-model-invocation`). */
+export const mustDefine = (marker) => ({ key: "must_define", field: marker });
+/** Every body section whose heading *starts with* `heading` carries `marker` in its body. */
+export const sectionContains = (heading, marker) => ({
+    key: "section_contains",
+    section: { heading, marker },
+});
+// Node-set/edge-scope predicates — a requirement's set-scope demands ride
 // these as ordinary clause values, the same four-channel `clause()` shape as
 // the node-scope predicates above.
 /** The satisfier set's size lies in the inclusive `[min, max]` bound. */
@@ -74,7 +100,7 @@ export const degree = (bounds) => {
 export function clause(predicate, opts) {
     return { predicate, severity: opts.severity, guidance: opts.guidance, cite: opts.cite };
 }
-/** An identity helper — types a requirement literal at the keystroke (`40-composition.md`). */
+/** An identity helper — types a requirement literal at the keystroke. */
 export function requirement(init) {
     return init;
 }

package/dist/src/declarations.d.ts

@@ -1,113 +1,54 @@
 /**
- * Declaration rows — the composed program's erased declarations
- * (`specs/architecture/20-surface.md`, "The seam — one implementation"; "The lock
- * and drift"). Every type erases at the seam: kinds, clauses, requirements, and
- * assembly facts compile to plain rows the engine reads. The **row shape** matches
- * the Rust lock's `[declaration]` families (`src/drift.rs` `Declarations`) — the
- * byte-parity lockstep two writers keep until single-writer lands
- * (`SDK-RECUT-CORPUS-FACE`). The same rows ride the internal versioned JSON pipe
- * ({@link declarationsToJson}) — not a designed IR, versioned in lockstep.
+ * Declaration rows — the composed program's erased declarations.
+ * Every type erases at the seam: kinds, clauses, requirements, and
+ * assembly facts compile to plain rows the engine reads. The **row shapes are the
+ * generated `ts-rs` bindings** (`./generated/`, derived from `src/drift.rs`), so a
+ * Rust-side row rename is a compile error here, never a silent shape drift. This
+ * module authors the builders that fill them; the same rows ride the internal
+ * versioned JSON pipe ({@link encodeSeam}) — not a designed IR, versioned
+ * in lockstep.
  */
 import type { Harness } from "./assembly.js";
-import type { Charset } from "./contract.js";
-/** One kind's declaration row — its identity and declared runtime facts. */
-export interface KindFactRow {
-    readonly name: string;
-    readonly provider?: string;
-    readonly governs_root: string;
-    readonly governs_glob: string;
-    readonly format?: string;
-    readonly unit_shape?: string;
-    readonly registration?: string;
-}
+import type { Declarations, Payload, RegistrationRow, SettingsRow } from "./generated/index.js";
+export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, SatisfiesRow, } from "./generated/index.js";
+/** The stable-sort ordering every declaration row family shares. */
+export declare function compareStrings(a: string, b: string): number;
 /**
- * One clause of a kind's effective contract, or one of a requirement's own
- * set-/edge-scope demands — the same row shape either way (`src/drift.rs`
- * `ClauseRow`). `kind` is absent when this row is nested inside a
- * `RequirementRow`'s own `clauses`: a requirement's demand names no kind of its
- * own (`10-contracts.md`, "Decision: set-scope demands are clauses").
+ * The `registration` rows — every fields-only registration member (a hook, an MCP server)
+ * erased for the manifest write face, kind-then-key sorted so double emit is byte-stable.
+ * Each carries its identity (`kind`/`key`), its collection address (`manifest`/`keyPath`,
+ * the wire's snake_case `key_path`), and its folded typed fields — the entry value the
+ * engine's write face places under `key`. The one source `emit.ts`'s public
+ * {@link RegistrationFact} view also maps from, so the seam and the `EmitResult` sibling
+ * cannot disagree on what a manifest carries.
+ *
+ * # Throws
+ * If a fields-only member declares no collection address — it surfaces in no host manifest.
  */
-export interface ClauseRow {
-    readonly kind?: string;
-    readonly predicate: string;
-    readonly field?: string;
-    readonly severity: string;
-    /** The just-in-time teaching channel the predicate cannot encode (`10-contracts.md`, "guidance"). */
-    readonly guidance?: string;
-    /** The external-fact source backing the clause — a doc URL plus retrieved date (`10-contracts.md`, "cite"). */
-    readonly cite?: string;
-    /** The `count` predicate's satisfier-set-size bound. */
-    readonly count?: {
-        readonly min: number;
-        readonly max: number;
-    };
-    /** The `membership` predicate's target requirement name. */
-    readonly target?: string;
-    /** The `degree` predicate's in/out edge-count bound. */
-    readonly degree?: {
-        readonly incoming?: {
-            readonly min?: number;
-            readonly max?: number;
-        };
-        readonly outgoing?: {
-            readonly min?: number;
-            readonly max?: number;
-        };
-    };
-    /** The `min_len`/`max_len`/`max_lines` predicate's scalar bound. */
-    readonly bound?: {
-        readonly min?: number;
-        readonly max?: number;
-    };
-    /** The `allowed_chars` predicate's declared character class. */
-    readonly charset?: Charset;
-    /** The `forbidden_keys` predicate's forbidden key list. */
-    readonly keys?: readonly string[];
-    /** The `deny` predicate's forbidden value list. */
-    readonly values?: readonly string[];
-}
+export declare function registrationRows(harness: Harness): RegistrationRow[];
 /**
- * One named requirement's declaration row — the scalar facets plus its own
- * `count`/`unique`/`membership`/`degree` clause rows (`10-contracts.md`,
- * "Decision: set-scope demands are clauses"): the requirement's `clauses` array
- * is the whole of its set-/edge-scope demand, no facet columns beside it.
+ * The `settings` rows — the assembly's harness-level residual settings keys, each folded
+ * into the settings.json manifest's opaque residue at emit. Key-sorted so double emit is
+ * byte-stable. Seam-inbound: the value lives in the projected manifest, never the lock.
  */
-export interface RequirementRow {
-    readonly name: string;
-    readonly kind?: string;
-    readonly required: boolean;
-    readonly clauses: readonly ClauseRow[];
-    readonly verified_by?: string;
-}
-/** One assembly-scope fact — authority or an edge. */
-export interface AssemblyFactRow {
-    readonly fact: string;
-    readonly value?: string;
-    readonly from?: string;
-    readonly field?: string;
-    readonly to?: string;
-}
-/** One member→requirement fill edge — a resolved `satisfies` key. */
-export interface SatisfiesRow {
-    readonly member: string;
-    readonly requirement: string;
-}
-/** The five declaration families — the whole erased program the lock and pipe carry. */
-export interface Declarations {
-    readonly kinds: readonly KindFactRow[];
-    readonly clauses: readonly ClauseRow[];
-    readonly requirements: readonly RequirementRow[];
-    readonly assembly: readonly AssemblyFactRow[];
-    readonly satisfies: readonly SatisfiesRow[];
-}
-/** Compile a harness into its five declaration families — the erased program. */
+export declare function settingsRows(harness: Harness): SettingsRow[];
+/** Every requirement name a `satisfies` claim may fill — assembly `require` ∪ member `requires`. */
+export declare function declaredRequirements(harness: Harness): Set<string>;
+/**
+ * Every address a mention may name — declared requirement names ∪ each member's
+ * `kind:name`. Shared by `emit.ts` (a member-level `Text` body's mentions) and
+ * this module (an embedded member's `Text` leaves) — the one resolution-check
+ * set, so a leaf mention and a member mention are held to the identical bar.
+ */
+export declare function declaredAddresses(harness: Harness): Set<string>;
+/** Compile a harness into its seven declaration families — the erased program. */
 export declare function compileDeclarations(harness: Harness): Declarations;
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */
 export declare const SEAM_VERSION = 2;
 /**
- * Serialize the declaration rows to the internal versioned JSON pipe
- * (`20-surface.md`, "The seam"). Not a designed IR — a stable public interchange
- * is admitted only when its consumer lands. Deterministic: insertion-ordered keys
- * and a trailing newline, so a re-emit is byte-identical (law 5).
+ * Serialize the seam payload to the internal versioned JSON pipe — `encodeSeam`
+ * stamps `version`, so the caller supplies the rest of the {@link Payload}.
+ * Deterministic: insertion-ordered keys and a trailing newline, so a re-emit is
+ * byte-identical.
  */
-export declare function declarationsToJson(declarations: Declarations): string;
+export declare function encodeSeam(payload: Omit<Payload, "version">): string;