@dtmd/temper 0.0.1

package/README.md

@@ -0,0 +1,57 @@
+# temper-sdk — the authoring face
+
+The typed module library the ratified corpus names as temper's authoring
+medium (`specs/intent/00-intent.md`, the SDK Decision; `specs/architecture/20-surface.md`,
+"The seam — one implementation"). A harness author composes members as typed
+values in the **six-noun model**; `emit` compiles the whole into the declaration
+rows the engine reads, a byte-faithful `.claude/**` projection, and the lock. The
+SDK implements **no semantics** — every type erases at the seam, and the engine
+consumes only declared data, offline, no Node.
+
+## The six-noun face
+
+- **`harness()`** — the assembly as one typed value: `members · expect ·
+  require · settings · reachability` (`specs/architecture/40-composition.md`).
+- **`kind<T>()` / `genre<T>()`** — the engine room: a kind is a typed
+  constructor plus five facts of runtime residue (label, locus, layout,
+  registration, edge fields — `specs/architecture/15-kinds.md`). The built-in
+  Claude Code kinds `rule` / `skill` / `memory` are ordinary `kind<T>()` values.
+- **Clause values** — `clause(predicate, { severity, guidance, cite })` over the
+  closed predicate algebra (`required`, `maxLines`, …); a floor is an exported
+  clause array, adopted by spread in `expect` (`specs/architecture/10-contracts.md`).
+- **`needs`** — the capabilities a member uses (`bash("git diff")`); emit derives
+  the permission union, so a permission is never authored twice.
+- **`file()` / `` text`…` `` / `blocks()`** — the three prose constructors, one
+  field type; the author's words land byte-identical to their authored text.
+
+## What `emit` produces
+
+One deterministic pass over the harness, double-emit verified (law 5):
+
+- **Declaration rows** — the erased program (kind facts, clauses, requirements,
+  assembly facts) on the internal versioned JSON pipe and in the lock's
+  `[declaration]` families, byte-matching the Rust lock shape (`src/drift.rs`) —
+  the byte-parity lockstep two writers keep until single-writer lands.
+- **A byte-faithful projection** — each `rule` / `skill` / `memory` member
+  compiled whole to its `.claude/**` locus; install's placement lines round-trip.
+- **The lock** — rollup provenance/emit fingerprints plus the declaration rows.
+
+Emit is **total** (members are the only source), **refuses** before it writes on
+a broken source (a dangling `satisfies`, an unfilled `required`, an unresolved
+mention), and is **byte-reproducible**. `writeEmit` lands the lock and the
+projection on disk; the JSON pipe is in-flight, not a committed artifact.
+
+## Stated bounds — each a named follow-on, never silently faked
+
+- **`blocks()` composes now, renders later** — the shared genre fence format is
+  `(genre-fence-format)`, deferred until its first consumer; emit refuses to
+  project a `blocks()` body until then.
+- **The permission union is carried as data** — the fold into the settings
+  artifact lands with the hook/MCP kinds it folds many-to-one.
+- **Publish name/scope** pending the PACKAGING-CHANNELS ruling; `private: true`.
+
+## Tests
+
+`pnpm --dir sdk test` — `tsc` (the keystroke wall) then `node --test`, including
+projection byte-parity and lock fingerprints against real Rust output, and the
+declaration-row byte shape against the Rust `[declaration]` families.

package/dist/src/assembly.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The assembly — `harness()` takes the whole as one typed value
+ * (`specs/architecture/40-composition.md`): `Harness = members · expect · require ·
+ * settings · reachability`. Like every SDK type it erases at the seam — the
+ * engine never sees the constructor, only the declaration rows it compiles to
+ * (`20-surface.md`). There is no second authoring surface: no `temper.toml`, no
+ * roster/bindings dialect (the Decision rejects both); composing partial
+ * harnesses is ordinary code.
+ */
+import type { Member, KindDefinition } from "./kind.js";
+import type { Clause, Requirement, Severity } from "./contract.js";
+/**
+ * One `expect` binding — universal: every member of `kind` owes these clauses
+ * (`40-composition.md`). Keyed by the kind **value**, an import never a string;
+ * binding is implicit — a floor is just a clause array spread into `clauses`.
+ */
+export interface ExpectBinding {
+    readonly kind: KindDefinition<object>;
+    readonly clauses: readonly Clause[];
+}
+/** The composed harness — the five fields, erased to rows at the seam. */
+export interface Harness {
+    /** The member roster — the assembly's imports (`40-composition.md`, "`members`"). */
+    readonly members: readonly Member[];
+    /** Universal clause bindings, keyed by kind value. */
+    readonly expect: readonly ExpectBinding[];
+    /** Existential obligations the harness must contain a fill for, keyed by name. */
+    readonly require: Readonly<Record<string, Requirement>>;
+    /** The residual harness-level settings with no member home (a shrinking list). */
+    readonly settings: Readonly<Record<string, unknown>>;
+    /** The dead-registration dial — the severity of an unreachable member, or absent (no findings). */
+    readonly reachability?: Severity;
+}
+/**
+ * Compose the harness from its five fields — ordinary code, Turing-completeness
+ * quarantined at authoring time (`00-intent.md`, the SDK Decision). Absent
+ * fields default empty; the member list is the only required part.
+ */
+export declare function harness(init: {
+    members: readonly Member[];
+    expect?: readonly ExpectBinding[];
+    require?: Readonly<Record<string, Requirement>>;
+    settings?: Readonly<Record<string, unknown>>;
+    reachability?: Severity;
+}): Harness;

package/dist/src/assembly.js

@@ -0,0 +1,23 @@
+/**
+ * The assembly — `harness()` takes the whole as one typed value
+ * (`specs/architecture/40-composition.md`): `Harness = members · expect · require ·
+ * settings · reachability`. Like every SDK type it erases at the seam — the
+ * engine never sees the constructor, only the declaration rows it compiles to
+ * (`20-surface.md`). There is no second authoring surface: no `temper.toml`, no
+ * roster/bindings dialect (the Decision rejects both); composing partial
+ * harnesses is ordinary code.
+ */
+/**
+ * Compose the harness from its five fields — ordinary code, Turing-completeness
+ * quarantined at authoring time (`00-intent.md`, the SDK Decision). Absent
+ * fields default empty; the member list is the only required part.
+ */
+export function harness(init) {
+    return {
+        members: init.members,
+        expect: init.expect ?? [],
+        require: init.require ?? {},
+        settings: init.settings ?? {},
+        reachability: init.reachability,
+    };
+}

package/dist/src/builtins.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The built-in Claude Code kinds — the face nouns a harness author imports
+ * (`specs/architecture/15-kinds.md`, "Built-in and custom kinds"). Each is an
+ * ordinary `kind<T>()` value built with the same constructor every provider uses
+ * (ownership not privilege). Their five facts are external facts about the Claude
+ * Code harness, cited at the point of claim.
+ *
+ * In the shipped product these live in the published `@temper/claude-code` module
+ * (`50-distribution.md`); here they are the SDK's own exports, the first dogfood.
+ */
+import type { KindDefinition } from "./kind.js";
+import type { Prose } from "./prose.js";
+/** A Claude Code skill — a directory whose entry file is `SKILL.md` with YAML frontmatter. */
+export interface Skill {
+    /**
+     * The description trigger — always in context; the body loads on invocation
+     * (code.claude.com/docs/en/skills, retrieved 2026-07-02).
+     */
+    readonly description: string;
+    /** The optional license field the skill spec carries (agentskills.io/specification). */
+    readonly license?: string;
+    readonly prose?: Prose;
+}
+/**
+ * `skill` — `.claude/skills/<name>/SKILL.md`, a directory unit, YAML frontmatter
+ * carrying `name` then `description`; registers a description trigger
+ * (code.claude.com/docs/en/skills, agentskills.io/specification, retrieved
+ * 2026-07-02).
+ */
+export declare const skill: KindDefinition<Skill>;
+/** A Claude Code rule — a flat markdown file with an optional `paths` scope. */
+export interface Rule {
+    /**
+     * The path scope — a present list matching zero files is a dead edge; an absent
+     * one loads unconditionally (code.claude.com/docs/en/memory, retrieved 2026-07-02).
+     */
+    readonly paths?: readonly string[];
+    readonly prose?: Prose;
+}
+/**
+ * `rule` — `.claude/rules/<name>.md`, a lone file (identity from the stem), YAML
+ * frontmatter; registers a path scope (code.claude.com/docs/en/memory, retrieved
+ * 2026-07-02).
+ */
+export declare const rule: KindDefinition<Rule>;
+/** A Claude Code memory file — `CLAUDE.md`, loaded in full at launch, no frontmatter. */
+export interface Memory {
+    readonly prose?: Prose;
+}
+/**
+ * `memory` — a root `<name>.md` (`CLAUDE.md`, `AGENTS.md`), a lone file loaded
+ * unconditionally, with **no frontmatter** (code.claude.com/docs/en/memory,
+ * retrieved 2026-07-02): the whole file is the body, so the kind declares no
+ * `format`. Its discovery locus is any-depth (a `CLAUDE.md` at any directory);
+ * a module-carried memory projects the root file.
+ */
+export declare const memory: KindDefinition<Memory>;

package/dist/src/builtins.js

@@ -0,0 +1,50 @@
+/**
+ * The built-in Claude Code kinds — the face nouns a harness author imports
+ * (`specs/architecture/15-kinds.md`, "Built-in and custom kinds"). Each is an
+ * ordinary `kind<T>()` value built with the same constructor every provider uses
+ * (ownership not privilege). Their five facts are external facts about the Claude
+ * Code harness, cited at the point of claim.
+ *
+ * In the shipped product these live in the published `@temper/claude-code` module
+ * (`50-distribution.md`); here they are the SDK's own exports, the first dogfood.
+ */
+import { kind } from "./kind.js";
+/**
+ * `skill` — `.claude/skills/<name>/SKILL.md`, a directory unit, YAML frontmatter
+ * carrying `name` then `description`; registers a description trigger
+ * (code.claude.com/docs/en/skills, agentskills.io/specification, retrieved
+ * 2026-07-02).
+ */
+export const skill = kind({
+    name: "skill",
+    locus: { kind: "at", root: ".claude/skills", glob: "*/SKILL.md" },
+    format: "yaml-frontmatter",
+    unitShape: "directory",
+    registration: { via: "description-trigger", field: "description" },
+    identityField: "name",
+});
+/**
+ * `rule` — `.claude/rules/<name>.md`, a lone file (identity from the stem), YAML
+ * frontmatter; registers a path scope (code.claude.com/docs/en/memory, retrieved
+ * 2026-07-02).
+ */
+export const rule = kind({
+    name: "rule",
+    locus: { kind: "at", root: ".claude/rules", glob: "*.md" },
+    format: "yaml-frontmatter",
+    unitShape: "file",
+    registration: { via: "paths-match", field: "paths" },
+});
+/**
+ * `memory` — a root `<name>.md` (`CLAUDE.md`, `AGENTS.md`), a lone file loaded
+ * unconditionally, with **no frontmatter** (code.claude.com/docs/en/memory,
+ * retrieved 2026-07-02): the whole file is the body, so the kind declares no
+ * `format`. Its discovery locus is any-depth (a `CLAUDE.md` at any directory);
+ * a module-carried memory projects the root file.
+ */
+export const memory = kind({
+    name: "memory",
+    locus: { kind: "at", root: ".", glob: "**/CLAUDE.md" },
+    unitShape: "file",
+    registration: { via: "always" },
+});

package/dist/src/contract.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Contracts — clauses and requirements as typed values (`specs/architecture/10-contracts.md`).
+ * A clause is `predicate · severity · guidance · cite`; a requirement is
+ * `means · kind · required · count? · unique? · membership? · degree? · verifiedBy?`.
+ * Both erase to compiled data at the seam (`20-surface.md`): 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).
+ */
+import type { KindDefinition } from "./kind.js";
+/** A clause's delivery posture: `required` gate-blocks, `advisory` reports. */
+export type Severity = "required" | "advisory";
+/**
+ * A member of the closed predicate algebra (`10-contracts.md`). The compiled
+ * clause row records only `key`, the targeted `field` (when it names one), and
+ * severity — the reduced shape the lock and the JSON pipe both carry; a
+ * predicate's scalar bounds (`args`) stay author-side until the fuller
+ * interchange lands its consumer (the entry gate, `20-surface.md`).
+ */
+export interface Predicate {
+    /** The predicate's clause key (`required`, `max_len`, `max_lines`, …). */
+    readonly key: string;
+    /** The field (or marker) the predicate constrains, when it names one. */
+    readonly field?: string;
+    /** The predicate's scalar bounds — author-side; not yet in the erased row. */
+    readonly args?: Readonly<Record<string, number>>;
+}
+/** A field or marker is present. */
+export declare const required: (field: string) => Predicate;
+/** The field's parsed scalar type is as declared. */
+export declare const type: (field: string) => Predicate;
+/** The field's value is at least `n` characters. */
+export declare const minLen: (field: string, n: number) => Predicate;
+/** The field's value is at most `n` characters. */
+export declare const maxLen: (field: string, n: number) => Predicate;
+/** The field's characters are drawn from a declared class (`allowed_chars`). */
+export declare const allowedChars: (field: string) => Predicate;
+/** The member's body is at most `n` lines. */
+export declare const maxLines: (n: number) => Predicate;
+/** The forbidden keys (e.g. the Cursor `globs`/`alwaysApply` keys) are absent. */
+export declare const forbiddenKeys: () => Predicate;
+/** The named headings are present. */
+export declare const requireSections: () => Predicate;
+/** The member's name matches its directory. */
+export declare const nameMatchesDir: () => Predicate;
+/**
+ * A clause — a predicate the author marks with a severity, the just-in-time
+ * guidance the predicate cannot encode, and the external-fact `cite` that makes
+ * a maintained floor auditable (`10-contracts.md`, "The clause").
+ */
+export interface Clause {
+    readonly predicate: Predicate;
+    readonly severity: Severity;
+    readonly guidance?: string;
+    readonly cite?: string;
+}
+/** Compose a clause value — a predicate under a declared severity, with optional guidance/cite. */
+export declare function clause(predicate: Predicate, opts: {
+    severity: Severity;
+    guidance?: string;
+    cite?: string;
+}): Clause;
+/**
+ * A requirement — a named obligation on the harness (`10-contracts.md`,
+ * "Requirements"). `means` is the authored intent, carried never interpreted;
+ * `kind` constrains what may fill it **by import** (a value, never a string);
+ * `required` is the posture declaration; the set-scope facets measure the
+ * satisfier set; `verifiedBy` wires the behavioral remainder.
+ */
+export interface Requirement {
+    readonly means: string;
+    readonly kind?: KindDefinition<object>;
+    readonly required?: boolean;
+    readonly count?: {
+        readonly min?: number;
+        readonly max?: number;
+    };
+    readonly unique?: string;
+    readonly membership?: string;
+    readonly degree?: string;
+    readonly verifiedBy?: string;
+}
+/** An identity helper — types a requirement literal at the keystroke (`40-composition.md`). */
+export declare function requirement(init: Requirement): Requirement;

package/dist/src/contract.js

@@ -0,0 +1,36 @@
+/**
+ * Contracts — clauses and requirements as typed values (`specs/architecture/10-contracts.md`).
+ * A clause is `predicate · severity · guidance · cite`; a requirement is
+ * `means · kind · required · count? · unique? · membership? · degree? · verifiedBy?`.
+ * Both erase to compiled data at the seam (`20-surface.md`): 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).
+ */
+// Node-scope predicates (`10-contracts.md`, "The predicate algebra").
+/** A field or marker is present. */
+export const required = (field) => ({ key: "required", field });
+/** The field's parsed scalar type is as declared. */
+export const type = (field) => ({ key: "type", field });
+/** The field's value is at least `n` characters. */
+export const minLen = (field, n) => ({ key: "min_len", field, args: { min: n } });
+/** The field's value is at most `n` characters. */
+export const maxLen = (field, n) => ({ key: "max_len", field, args: { max: n } });
+/** The field's characters are drawn from a declared class (`allowed_chars`). */
+export const allowedChars = (field) => ({ key: "allowed_chars", field });
+/** The member's body is at most `n` lines. */
+export const maxLines = (n) => ({ key: "max_lines", args: { max: n } });
+/** The forbidden keys (e.g. the Cursor `globs`/`alwaysApply` keys) are absent. */
+export const forbiddenKeys = () => ({ key: "forbidden_keys" });
+/** The named headings are present. */
+export const requireSections = () => ({ key: "require_sections" });
+/** The member's name matches its directory. */
+export const nameMatchesDir = () => ({ key: "name-matches-dir" });
+/** Compose a clause value — a predicate under a declared severity, with optional guidance/cite. */
+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`). */
+export function requirement(init) {
+    return init;
+}

package/dist/src/declarations.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+import type { Harness } from "./assembly.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 activation?: string;
+}
+/** One clause of a kind's effective contract, reduced to the lock's columns. */
+export interface ClauseRow {
+    readonly kind: string;
+    readonly predicate: string;
+    readonly field?: string;
+    readonly severity: string;
+}
+/** One named requirement's declaration row, reduced to the scalar facets the lock records. */
+export interface RequirementRow {
+    readonly name: string;
+    readonly kind?: string;
+    readonly package?: string;
+    readonly required: boolean;
+    readonly verified_by?: string;
+}
+/** One assembly-scope fact — authority, reachability, or an edge. */
+export interface AssemblyFactRow {
+    readonly fact: string;
+    readonly value?: string;
+    readonly from?: string;
+    readonly field?: string;
+    readonly to?: string;
+}
+/** The four 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[];
+}
+/** Compile a harness into its four 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 = 1;
+/**
+ * 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).
+ */
+export declare function declarationsToJson(declarations: Declarations): string;

package/dist/src/declarations.js

@@ -0,0 +1,133 @@
+/**
+ * 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.
+ */
+/** The lock label for a kind's declared registration — the activation spelling. */
+function activationLabel(registration) {
+    switch (registration.via) {
+        case "always":
+            return "always";
+        case "description-trigger":
+            return `description-trigger(${registration.field})`;
+        case "paths-match":
+            return `paths-match(${registration.field})`;
+        case "event":
+            return `event(${registration.field})`;
+        case "connection":
+            return "connection";
+    }
+}
+/** One kind's fact row — the `at` locus supplies `governs_root`/`governs_glob`. */
+function kindFactRow(facts) {
+    if (facts.locus.kind !== "at") {
+        // A genre inherits its world residue through its host; it carries no `at`
+        // locus, so it takes no kind-fact row (`15-kinds.md`). Callers filter these
+        // out before this point.
+        throw new Error(`kind \`${facts.name}\` is a genre — it carries no locus-bearing kind fact.`);
+    }
+    return {
+        name: facts.name,
+        provider: facts.provider,
+        governs_root: facts.locus.root,
+        governs_glob: facts.locus.glob,
+        format: facts.format,
+        unit_shape: facts.unitShape,
+        activation: activationLabel(facts.registration),
+    };
+}
+/** The distinct locus-bearing kinds in play — member kinds ∪ expect kinds, name-sorted. */
+function kindsInPlay(harness) {
+    const byName = new Map();
+    for (const member of harness.members)
+        byName.set(member.facts.name, member.facts);
+    for (const binding of harness.expect)
+        byName.set(binding.kind.facts.name, binding.kind.facts);
+    return [...byName.values()]
+        .filter((facts) => facts.locus.kind === "at")
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/** The requirement rows — assembly `require` and every member's `requires`, one namespace. */
+function requirementRows(harness) {
+    const merged = new Map();
+    const publish = (name, requirement, source) => {
+        const existing = merged.get(name);
+        if (existing !== undefined && existing !== requirement) {
+            // One namespace, one fill mechanism; a cross-publisher name collision is an
+            // admissibility finding, never a shadowing rule (`10-contracts.md`).
+            throw new Error(`requirement \`${name}\` is published twice (${source} collides with an earlier ` +
+                `publisher) — a name collision across publishers is an admissibility finding.`);
+        }
+        merged.set(name, requirement);
+    };
+    for (const [name, requirement] of Object.entries(harness.require))
+        publish(name, requirement, "the assembly");
+    for (const member of harness.members) {
+        for (const [name, requirement] of Object.entries(member.requires)) {
+            publish(name, requirement, `member \`${member.name}\``);
+        }
+    }
+    return [...merged.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([name, requirement]) => ({
+        name,
+        kind: requirement.kind?.key,
+        required: requirement.required ?? false,
+        verified_by: requirement.verifiedBy,
+    }));
+}
+/**
+ * The assembly-scope facts, in a stable order: authority (always declared — the
+ * `shared` default anchors every harness until a surface-authority posture is
+ * authored), reachability when the dial is set, then one edge row per kind edge
+ * field (`40-composition.md`; `45-governance.md`).
+ */
+function assemblyFactRows(harness, kinds) {
+    const facts = [{ fact: "authority", value: "shared" }];
+    if (harness.reachability !== undefined) {
+        facts.push({ fact: "reachability", value: harness.reachability });
+    }
+    for (const kind of kinds) {
+        for (const edge of kind.edgeFields ?? []) {
+            facts.push({ fact: "edge", from: kind.name, field: edge.field, to: edge.to });
+        }
+    }
+    return facts;
+}
+/** Compile a harness into its four declaration families — the erased program. */
+export function compileDeclarations(harness) {
+    const kinds = kindsInPlay(harness);
+    const clauses = [];
+    for (const binding of [...harness.expect].sort((a, b) => (a.kind.key < b.kind.key ? -1 : a.kind.key > b.kind.key ? 1 : 0))) {
+        for (const clause of binding.clauses) {
+            clauses.push({
+                kind: binding.kind.key,
+                predicate: clause.predicate.key,
+                field: clause.predicate.field,
+                severity: clause.severity,
+            });
+        }
+    }
+    return {
+        kinds: kinds.map(kindFactRow),
+        clauses,
+        requirements: requirementRows(harness),
+        assembly: assemblyFactRows(harness, kinds),
+    };
+}
+/** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */
+export const SEAM_VERSION = 1;
+/**
+ * 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).
+ */
+export function declarationsToJson(declarations) {
+    return JSON.stringify({ version: SEAM_VERSION, ...declarations }, null, 2) + "\n";
+}

package/dist/src/emit.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Emit — the compile from the six-noun face to the committed seam
+ * (`specs/architecture/20-surface.md`, "Emit — total, byte-reproducible, refusing";
+ * "The seam — one implementation"). The SDK implements **no semantics**: emit
+ * produces plain data — the declaration rows the engine reads (the internal
+ * versioned JSON pipe and the lock's `[declaration]` families), a byte-faithful
+ * `.claude/**` projection, and the lock. Emit is total (members are the only
+ * source), refuses before it writes a byte on a broken source, and is
+ * byte-reproducible — double-emit verified at every run (law 5).
+ */
+import type { Harness } from "./assembly.js";
+import type { Projection } from "./project.js";
+import type { Declarations } from "./declarations.js";
+/** How a `file()` asset's module-relative path resolves at emit. */
+export interface ResolveOptions {
+    /** Base dir a `file()` module-relative path resolves against (default: cwd). */
+    readonly baseDir?: string;
+    /** The addresses a mention may name — resolution-checked; a mention cannot dangle. */
+    readonly mentionable?: ReadonlySet<string>;
+}
+/** Emit-time inputs beyond the harness — asset base dir and the committed-projection read root. */
+export interface EmitOptions {
+    /** Base dir a `file()` asset's module-relative path resolves against (default: cwd). */
+    readonly baseDir?: string;
+    /**
+     * The harness root the committed projection is read from so a re-emit carries
+     * install's placement lines through the whole-file re-emit (`20-surface.md`, the
+     * two-projectors seam). Absent reads no committed projection; [`writeEmit`]
+     * passes its `targetDir` here so a re-emit preserves them.
+     */
+    readonly projectionDir?: string;
+}
+/**
+ * A full emit's compiled outputs — the seam the engine reads plus the on-disk
+ * projection and lock (`20-surface.md`, "The seam"). All are a pure function of
+ * the harness, so [`emit`] double-verifies them and [`writeEmit`] lands them.
+ */
+export interface EmitResult {
+    /** The projection files, one per projected (rule/skill/memory) member. */
+    readonly projections: readonly Projection[];
+    /** The `lock.toml` bytes — rollup rows plus the `[declaration]` families. */
+    readonly lock: string;
+    /** The declaration rows — the erased program the lock and JSON pipe both carry. */
+    readonly declarations: Declarations;
+    /** The internal versioned JSON pipe to the engine — not a designed IR. */
+    readonly seam: string;
+    /**
+     * The derived permission list — the union of every member's `needs`, deduped and
+     * sorted (`20-surface.md`, "The permission list is derived, never authored").
+     * Folds into the settings artifact once hook/MCP members land; carried here as
+     * data until then.
+     */
+    readonly permissions: readonly string[];
+}
+/**
+ * Compile the whole face in one deterministic pass: the projection, the lock (its
+ * rollup and its declaration rows), the JSON pipe, and the derived permission
+ * union. Prose resolves once (`file()` assets read in, mentions resolution-checked
+ * against the harness's declared values). Double-emit verified — nondeterministic
+ * authoring is a loud failure, never a silent churn (law 5).
+ */
+export declare function emit(harness: Harness, options?: EmitOptions): EmitResult;
+/**
+ * Run a full [`emit`] and write its committed artifacts under `targetDir`: the
+ * lock to `lock.toml` and each projection to its `.claude/**` path (parent
+ * directories created). Whole-file writes — a projection is regenerated, never
+ * patched. The JSON pipe is in-flight, not a committed artifact, so it is not
+ * written (`20-surface.md`, "the committed seam" is artifacts plus lock).
+ */
+export declare function writeEmit(harness: Harness, targetDir: string, options?: EmitOptions): EmitResult;