@dtmd/temper 0.0.1

package/dist/src/emit.js

@@ -0,0 +1,187 @@
+/**
+ * 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 { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve as resolvePath } from "node:path";
+import { renderText } from "./prose.js";
+import { permissionUnion } from "./needs.js";
+import { projectMember } from "./project.js";
+import { lockRow, stampLock } from "./lock.js";
+import { compileDeclarations, declarationsToJson } from "./declarations.js";
+/**
+ * Resolve a member's prose to its final body bytes: a `file()` asset is read in
+ * byte-for-byte; a `text` body's mentions are resolution-checked (loud on a
+ * dangling address) and rendered by the one display rule; a `blocks()` body is
+ * refused until the fence format lands. The words are never reworded (law 5).
+ *
+ * # Throws
+ * If a `file()` asset does not resolve, a mention names no declared value, or a
+ * `blocks()` body is projected before `(genre-fence-format)` lands.
+ */
+function resolveBody(member, options) {
+    const prose = member.prose;
+    if (prose === undefined)
+        return "";
+    if (prose.kind === "file") {
+        const assetPath = resolvePath(options.baseDir ?? process.cwd(), prose.path);
+        try {
+            return readFileSync(assetPath, "utf8");
+        }
+        catch (cause) {
+            throw new Error(`member \`${member.name}\`: file() asset \`${prose.path}\` did not resolve ` +
+                `(looked at \`${assetPath}\`).`, { cause });
+        }
+    }
+    if (prose.kind === "blocks") {
+        throw new Error(`member \`${member.name}\`: a blocks() body renders through the genre fence format, ` +
+            `deferred until its first consumer lands ((genre-fence-format), specs/architecture/15-kinds.md).`);
+    }
+    const mentionable = options.mentionable ?? new Set();
+    for (const mention of prose.mentions) {
+        if (!mentionable.has(mention.target.address)) {
+            throw new Error(`member \`${member.name}\`: mention of \`${mention.target.address}\` resolves to no ` +
+                `declared value — a mention cannot dangle (specs/architecture/45-governance.md).`);
+        }
+    }
+    return renderText(prose);
+}
+/** Every requirement name a `satisfies` claim may fill — assembly `require` ∪ member `requires`. */
+function declaredRequirements(harness) {
+    const set = new Set();
+    for (const name of Object.keys(harness.require))
+        set.add(name);
+    for (const member of harness.members) {
+        for (const name of Object.keys(member.requires))
+            set.add(name);
+    }
+    return set;
+}
+/** Every address a mention may name — declared requirement names ∪ each member's `kind:name`. */
+function declaredAddresses(harness) {
+    const set = declaredRequirements(harness);
+    for (const member of harness.members)
+        set.add(`${member.kind}:${member.name}`);
+    return set;
+}
+/**
+ * The two declare-side refusals emit runs before it compiles a byte
+ * (`20-surface.md`, "Emit refuses before it writes"): a `satisfies` claim naming
+ * no declared requirement (a dangling join), and a `required` requirement no
+ * member fills (an unfilled required requirement).
+ *
+ * # Throws
+ * On a dangling `satisfies` join or an unfilled `required` requirement.
+ */
+function refuseBrokenSource(harness) {
+    const requirements = declaredRequirements(harness);
+    const filled = new Set();
+    for (const member of harness.members) {
+        for (const name of member.satisfies) {
+            if (!requirements.has(name)) {
+                throw new Error(`member \`${member.name}\`: \`satisfies\` claims requirement \`${name}\`, which no ` +
+                    `harness-level or member-published requirement declares — a dangling join ` +
+                    `(specs/architecture/20-surface.md, "Emit refuses before it writes").`);
+            }
+            filled.add(name);
+        }
+    }
+    const requiredSources = [];
+    for (const [name, requirement] of Object.entries(harness.require)) {
+        if (requirement.required)
+            requiredSources.push([name, "the assembly"]);
+    }
+    for (const member of harness.members) {
+        for (const [name, requirement] of Object.entries(member.requires)) {
+            if (requirement.required)
+                requiredSources.push([name, `member \`${member.name}\``]);
+        }
+    }
+    for (const [name, source] of requiredSources) {
+        if (!filled.has(name)) {
+            throw new Error(`required requirement \`${name}\` (declared by ${source}) is filled by no member's ` +
+                `\`satisfies\` — an unfilled required requirement ` +
+                `(specs/architecture/20-surface.md, "Emit refuses before it writes").`);
+        }
+    }
+}
+/** A member is projected iff its kind lives at a path locus (a genre member is not). */
+function isProjected(member) {
+    return member.facts.locus.kind === "at";
+}
+/** The harness's projected members as projection inputs, deterministically kind-then-name ordered. */
+function orderedProjectionInputs(harness, options) {
+    return [...harness.members]
+        .filter(isProjected)
+        .sort((a, b) => (a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0) ||
+        (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+        .map((member) => ({
+        facts: member.facts,
+        name: member.name,
+        fields: member.fields,
+        body: resolveBody(member, options),
+    }));
+}
+/**
+ * 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 function emit(harness, options = {}) {
+    refuseBrokenSource(harness);
+    const resolve = {
+        mentionable: declaredAddresses(harness),
+        baseDir: options.baseDir,
+    };
+    const compile = () => {
+        const inputs = orderedProjectionInputs(harness, resolve);
+        const projections = inputs.map((input) => projectMember(input, { projectionDir: options.projectionDir }));
+        const rows = inputs.map((input, i) => lockRow(input.facts.name, projections[i]));
+        const declarations = compileDeclarations(harness);
+        return {
+            projections,
+            lock: stampLock(rows, declarations),
+            declarations,
+            seam: declarationsToJson(declarations),
+            permissions: permissionUnion(harness.members.flatMap((member) => [...member.needs])),
+        };
+    };
+    const first = compile();
+    const second = compile();
+    if (first.lock !== second.lock ||
+        first.seam !== second.seam ||
+        !sameProjections(first.projections, second.projections)) {
+        throw new Error("double-emit divergence: two passes over the same harness produced different bytes — " +
+            "authoring code is nondeterministic (a timestamp? an unordered map?).");
+    }
+    return first;
+}
+/** Whether two projection lists are byte-identical, path and bytes both. */
+function sameProjections(a, b) {
+    return a.length === b.length && a.every((p, i) => p.path === b[i].path && p.bytes === b[i].bytes);
+}
+/**
+ * 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 function writeEmit(harness, targetDir, options = {}) {
+    const result = emit(harness, { ...options, projectionDir: options.projectionDir ?? targetDir });
+    writeFileSync(join(targetDir, "lock.toml"), result.lock);
+    for (const projection of result.projections) {
+        const path = join(targetDir, projection.path);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, projection.bytes);
+    }
+    return result;
+}

package/dist/src/genres.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Genre values — prose that declares its own anatomy (`specs/architecture/15-kinds.md`,
+ * "A genre is a kind at the block locus"; ratified `specs/intent/00-intent.md`, the
+ * genre Decision). A genre value's meaning-carrying fields are prose leaves —
+ * authored strings, law-5 protected one by one — plus keyed sibling collections.
+ * These constructors carry the **shape only**: any predicate over a genre value
+ * (a decision names at least one rejected alternative) is a clause some module
+ * ships, never here (`15-kinds.md`, the genre Decision).
+ *
+ * They are the posture-3 spelling — fully composed values passed to `blocks()`
+ * (`20-surface.md`). The byte-identical posture-2 fence render awaits
+ * `(genre-fence-format)`, deferred until its first consumer lands.
+ */
+/**
+ * A genre value serialized whole: leaves are authored strings keyed by field
+ * name; sibling collections are keyed at every level (`rejected."baked-projection"`),
+ * never positional — leaf addresses are structural and keyed (`20-surface.md`,
+ * the leaf-address Decision).
+ */
+export interface GenreValue {
+    /** The genre name — `decision`, `law`, `bound`, or a project's own. */
+    readonly genre: string;
+    /** The value's key — the identity a leaf address carries (`surface-authority`). */
+    readonly key: string;
+    /** Prose leaves: authored strings, law-5 protected one by one. */
+    readonly leaves: Readonly<Record<string, string>>;
+    /** Keyed sibling collections: collection → entry key → field → authored string. */
+    readonly collections: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, string>>>>>>;
+}
+/** A rejected alternative: keyed by option slug, its rationale a prose leaf. */
+export interface Alternative {
+    readonly because: string;
+}
+/**
+ * The `decision` genre — the Chosen/Rejected convention, typed. Sibling
+ * collections are keyed by option slug, never positional: positional addresses
+ * die on insertion and reorder, which is exactly when impact must survive.
+ */
+export declare function decision(init: {
+    key: string;
+    chosen: string;
+    rejected?: Readonly<Record<string, Alternative>>;
+}): GenreValue;
+/** The `law` genre — a numbered law's statement with its named bounds. */
+export declare function law(init: {
+    key: string;
+    statement: string;
+    bounds?: Readonly<Record<string, {
+        claim: string;
+    }>>;
+}): GenreValue;
+/** The `bound` genre — the honest bound: claim, deferral, unlock condition. */
+export declare function bound(init: {
+    key: string;
+    claim: string;
+    deferred: string;
+    unlock: string;
+}): GenreValue;
+/** A project's own genre — the same machinery, an author-declared shape. */
+export declare function genreValue(init: {
+    genre: string;
+    key: string;
+    leaves: Readonly<Record<string, string>>;
+    collections?: GenreValue["collections"];
+}): GenreValue;

package/dist/src/genres.js

@@ -0,0 +1,57 @@
+/**
+ * Genre values — prose that declares its own anatomy (`specs/architecture/15-kinds.md`,
+ * "A genre is a kind at the block locus"; ratified `specs/intent/00-intent.md`, the
+ * genre Decision). A genre value's meaning-carrying fields are prose leaves —
+ * authored strings, law-5 protected one by one — plus keyed sibling collections.
+ * These constructors carry the **shape only**: any predicate over a genre value
+ * (a decision names at least one rejected alternative) is a clause some module
+ * ships, never here (`15-kinds.md`, the genre Decision).
+ *
+ * They are the posture-3 spelling — fully composed values passed to `blocks()`
+ * (`20-surface.md`). The byte-identical posture-2 fence render awaits
+ * `(genre-fence-format)`, deferred until its first consumer lands.
+ */
+/**
+ * The `decision` genre — the Chosen/Rejected convention, typed. Sibling
+ * collections are keyed by option slug, never positional: positional addresses
+ * die on insertion and reorder, which is exactly when impact must survive.
+ */
+export function decision(init) {
+    return {
+        genre: "decision",
+        key: init.key,
+        leaves: { chosen: init.chosen },
+        collections: {
+            rejected: Object.fromEntries(Object.entries(init.rejected ?? {}).map(([slug, alt]) => [slug, { because: alt.because }])),
+        },
+    };
+}
+/** The `law` genre — a numbered law's statement with its named bounds. */
+export function law(init) {
+    return {
+        genre: "law",
+        key: init.key,
+        leaves: { statement: init.statement },
+        collections: {
+            bounds: Object.fromEntries(Object.entries(init.bounds ?? {}).map(([slug, bound]) => [slug, { claim: bound.claim }])),
+        },
+    };
+}
+/** The `bound` genre — the honest bound: claim, deferral, unlock condition. */
+export function bound(init) {
+    return {
+        genre: "bound",
+        key: init.key,
+        leaves: { claim: init.claim, deferred: init.deferred, unlock: init.unlock },
+        collections: {},
+    };
+}
+/** A project's own genre — the same machinery, an author-declared shape. */
+export function genreValue(init) {
+    return {
+        genre: init.genre,
+        key: init.key,
+        leaves: init.leaves,
+        collections: init.collections ?? {},
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * temper's authoring face — the six-noun model as a typed module library
+ * (`specs/intent/00-intent.md`, the SDK Decision; `specs/architecture/20-surface.md`).
+ * A harness author imports plain nouns — the built-in kinds, `harness()`, the
+ * clause and requirement constructors, `needs`, and the three prose constructors —
+ * and composes members as typed values. `emit` compiles the whole into the
+ * declaration rows the engine reads, a byte-faithful projection, and the lock;
+ * every type erases at the seam, and Turing-completeness stays quarantined at
+ * authoring time.
+ */
+export type { Blocks, File, Mention, Mentionable, Prose, Text } from "./prose.js";
+export { blocks, file, renderText, text } from "./prose.js";
+export type { Alternative, GenreValue } from "./genres.js";
+export { bound, decision, genreValue, law } from "./genres.js";
+export type { Capability } from "./needs.js";
+export { bash, capability, permissionUnion } from "./needs.js";
+export type { Clause, Predicate, Requirement, Severity } from "./contract.js";
+export { allowedChars, clause, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, requireSections, requirement, type, } from "./contract.js";
+export type { EdgeField, Format, KindDefinition, KindFacts, Locus, Member, MemberInit, Registration, UnitShape, } from "./kind.js";
+export { genre, kind } from "./kind.js";
+export type { Memory, Rule, Skill } from "./builtins.js";
+export { memory, rule, skill } from "./builtins.js";
+export type { ExpectBinding, Harness } from "./assembly.js";
+export { harness } from "./assembly.js";
+export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, } from "./declarations.js";
+export { SEAM_VERSION, compileDeclarations, declarationsToJson } from "./declarations.js";
+export type { Projection, ProjectionInput, ProjectOptions } from "./project.js";
+export { placementLines, projectBytes, projectMember, projectionPath, renderField } from "./project.js";
+export type { LockRow } from "./lock.js";
+export { lockRow, sha256Hex, stampLock } from "./lock.js";
+export type { EmitOptions, EmitResult, ResolveOptions } from "./emit.js";
+export { emit, writeEmit } from "./emit.js";

package/dist/src/index.js

@@ -0,0 +1,21 @@
+/**
+ * temper's authoring face — the six-noun model as a typed module library
+ * (`specs/intent/00-intent.md`, the SDK Decision; `specs/architecture/20-surface.md`).
+ * A harness author imports plain nouns — the built-in kinds, `harness()`, the
+ * clause and requirement constructors, `needs`, and the three prose constructors —
+ * and composes members as typed values. `emit` compiles the whole into the
+ * declaration rows the engine reads, a byte-faithful projection, and the lock;
+ * every type erases at the seam, and Turing-completeness stays quarantined at
+ * authoring time.
+ */
+export { blocks, file, renderText, text } from "./prose.js";
+export { bound, decision, genreValue, law } from "./genres.js";
+export { bash, capability, permissionUnion } from "./needs.js";
+export { allowedChars, clause, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, requireSections, requirement, type, } from "./contract.js";
+export { genre, kind } from "./kind.js";
+export { memory, rule, skill } from "./builtins.js";
+export { harness } from "./assembly.js";
+export { SEAM_VERSION, compileDeclarations, declarationsToJson } from "./declarations.js";
+export { placementLines, projectBytes, projectMember, projectionPath, renderField } from "./project.js";
+export { lockRow, sha256Hex, stampLock } from "./lock.js";
+export { emit, writeEmit } from "./emit.js";

package/dist/src/kind.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Kinds — the engine room (`specs/architecture/15-kinds.md`, "A kind is a
+ * constructor plus five facts"). A kind is a plain typed surface — an interface
+ * `T` and a constructor `kind<T>()` — plus five facts of runtime residue: label,
+ * locus, layout, registration, and edge fields. `tsc` is the keystroke wall; every
+ * type erases at the seam, and what a kind leaves behind is those five facts,
+ * riding the lock as rows. Identity travels by import, never by string — a `kind`
+ * reference is the imported value (`15-kinds.md`, the built-ins-are-a-module
+ * Decision).
+ */
+import type { Prose } from "./prose.js";
+import type { Capability } from "./needs.js";
+import type { Requirement } from "./contract.js";
+/** The shape of the on-disk artifact a member projects to (fact 3, layout). */
+export type Format = "yaml-frontmatter";
+/** Whether a member is a lone file (identity from the stem) or a directory with an entry file. */
+export type UnitShape = "file" | "directory";
+/**
+ * A kind's **registration** — the declared edge between a member and the world
+ * (fact 4, `15-kinds.md`, "Registration"). Reachability is graph reachability
+ * from the world node over these edges.
+ */
+export type Registration = {
+    readonly via: "always";
+} | {
+    readonly via: "description-trigger";
+    readonly field: string;
+} | {
+    readonly via: "paths-match";
+    readonly field: string;
+} | {
+    readonly via: "event";
+    readonly field: string;
+} | {
+    readonly via: "connection";
+};
+/** One of a kind's fields that is a reference to another member — a graph edge (fact 5). */
+export interface EdgeField {
+    readonly field: string;
+    /** The target kind's name — the far end of the edge. */
+    readonly to: string;
+}
+/**
+ * A kind's **locus** (fact 2): members live at path globs (`at`) or as typed
+ * fenced blocks inside host documents (`genre`). An `at` locus is split root +
+ * glob so the kind fact row carries `governs_root`/`governs_glob` directly.
+ */
+export type Locus = {
+    readonly kind: "at";
+    readonly root: string;
+    readonly glob: string;
+} | {
+    readonly kind: "genre";
+    readonly withinHosts: readonly string[];
+};
+/** The five facts of a kind's runtime residue (`15-kinds.md`). */
+export interface KindFacts {
+    /** Fact 1, label — the compiled debug label findings speak; the kind's name. */
+    readonly name: string;
+    /** The declared provider authority, when the kind qualifies by one. */
+    readonly provider?: string;
+    /** Fact 2, locus — where members live. */
+    readonly locus: Locus;
+    /** Fact 3a, layout — the projection format; omitted for a frontmatterless kind. */
+    readonly format?: Format;
+    /** Fact 3b, layout — the on-disk unit shape. */
+    readonly unitShape: UnitShape;
+    /** Fact 4, registration — the world edge. */
+    readonly registration: Registration;
+    /**
+     * The frontmatter key the member's name writes under (a skill's `name`), or
+     * absent when identity is the file stem (a rule). A layout detail: it shapes
+     * the projected frontmatter, never the model.
+     */
+    readonly identityField?: string;
+    /** Fact 5, edge fields — the kind's fields that are references to other members. */
+    readonly edgeFields?: readonly EdgeField[];
+}
+/**
+ * One authored member — a typed value in the library (`20-surface.md`, "The
+ * member"). Kind identity travels by import (`facts`), never by string; the
+ * typed fields are flat at the top level, carried as an ordered pair list so the
+ * projected frontmatter key order is the author's.
+ */
+export interface Member {
+    /** The kind's name — its declaration-row and lock identity. */
+    readonly kind: string;
+    /** The kind's five facts — carried for projection and the declaration rows. */
+    readonly facts: KindFacts;
+    /** Identity within the kind. */
+    readonly name: string;
+    /** The member's words (`20-surface.md`, "Prose"). */
+    readonly prose?: Prose;
+    /** The kind's typed fields, flat and ordered — the projected frontmatter. */
+    readonly fields: ReadonlyArray<readonly [string, unknown]>;
+    /** String keys naming the requirements this member fills. */
+    readonly satisfies: readonly string[];
+    /** Requirements the member itself publishes, by name. */
+    readonly requires: Readonly<Record<string, Requirement>>;
+    /** The capabilities the member's behavior uses — the permission union's source. */
+    readonly needs: readonly Capability[];
+}
+/** The init a kind constructor takes — the framework keys plus the kind's typed fields `T`. */
+export type MemberInit<T> = {
+    readonly name: string;
+    readonly prose?: Prose;
+    readonly satisfies?: readonly string[];
+    readonly requires?: Readonly<Record<string, Requirement>>;
+    readonly needs?: readonly Capability[];
+} & T;
+/**
+ * A kind — a callable constructor carrying its five facts. Calling it builds a
+ * member; `key` (its name) keys `expect` and a `kind` reference in a requirement.
+ * The value *is* the identity (`15-kinds.md`, "identity travels by import").
+ */
+export interface KindDefinition<T> {
+    (init: MemberInit<T>): Member;
+    readonly facts: KindFacts;
+    readonly key: string;
+}
+/**
+ * Define a kind (`15-kinds.md`). Returns a constructor over the kind's typed
+ * fields `T`; every type erases at the seam, so what the returned member carries
+ * into emit is the five facts plus flat field data.
+ */
+export declare function kind<T extends object>(facts: KindFacts): KindDefinition<T>;
+/**
+ * Define a **genre** — a kind whose locus is `genre(within hosts)`: its members
+ * live as typed fenced blocks inside host documents instead of at their own
+ * paths (`15-kinds.md`, "A genre is a kind at the block locus"). Registration
+ * inherits through the host, so a genre carries no world edge of its own.
+ */
+export declare function genre<T extends object>(facts: {
+    name: string;
+    provider?: string;
+    withinHosts: readonly string[];
+    edgeFields?: readonly EdgeField[];
+}): KindDefinition<T>;

package/dist/src/kind.js

@@ -0,0 +1,63 @@
+/**
+ * Kinds — the engine room (`specs/architecture/15-kinds.md`, "A kind is a
+ * constructor plus five facts"). A kind is a plain typed surface — an interface
+ * `T` and a constructor `kind<T>()` — plus five facts of runtime residue: label,
+ * locus, layout, registration, and edge fields. `tsc` is the keystroke wall; every
+ * type erases at the seam, and what a kind leaves behind is those five facts,
+ * riding the lock as rows. Identity travels by import, never by string — a `kind`
+ * reference is the imported value (`15-kinds.md`, the built-ins-are-a-module
+ * Decision).
+ */
+/** The framework keys of a member init — everything else is a typed field (flat). */
+const FRAMEWORK_KEYS = new Set(["name", "prose", "satisfies", "requires", "needs"]);
+/**
+ * Build the ordered projected-frontmatter fields for a member: nothing for a
+ * frontmatterless kind (memory declares no `format`), else the identity field
+ * (when the kind writes its name into frontmatter) followed by the typed fields
+ * in the author's declared order.
+ */
+function orderedFields(facts, init) {
+    if (facts.format === undefined)
+        return [];
+    const typed = [];
+    for (const [key, value] of Object.entries(init)) {
+        if (!FRAMEWORK_KEYS.has(key))
+            typed.push([key, value]);
+    }
+    const head = facts.identityField !== undefined ? [[facts.identityField, init.name]] : [];
+    return [...head, ...typed];
+}
+/**
+ * Define a kind (`15-kinds.md`). Returns a constructor over the kind's typed
+ * fields `T`; every type erases at the seam, so what the returned member carries
+ * into emit is the five facts plus flat field data.
+ */
+export function kind(facts) {
+    const construct = (init) => ({
+        kind: facts.name,
+        facts,
+        name: init.name,
+        prose: init.prose,
+        fields: orderedFields(facts, init),
+        satisfies: init.satisfies ?? [],
+        requires: init.requires ?? {},
+        needs: init.needs ?? [],
+    });
+    return Object.assign(construct, { facts, key: facts.name });
+}
+/**
+ * Define a **genre** — a kind whose locus is `genre(within hosts)`: its members
+ * live as typed fenced blocks inside host documents instead of at their own
+ * paths (`15-kinds.md`, "A genre is a kind at the block locus"). Registration
+ * inherits through the host, so a genre carries no world edge of its own.
+ */
+export function genre(facts) {
+    return kind({
+        name: facts.name,
+        provider: facts.provider,
+        locus: { kind: "genre", withinHosts: facts.withinHosts },
+        unitShape: "file",
+        registration: { via: "always" },
+        edgeFields: facts.edgeFields,
+    });
+}

package/dist/src/lock.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The lock — tool-written provenance, emit fingerprints, and the program's
+ * declaration rows (`specs/architecture/20-surface.md`, "The lock and drift").
+ * Two row families: a per-member `[[<kind>]]` rollup (`name`, `source_path`,
+ * `source_hash`, `emit_hash`) and the `[declaration]` table's four sub-families
+ * (`[[declaration.kind]]`, `[[declaration.clause]]`, `[[declaration.requirement]]`,
+ * `[[declaration.assembly]]`). Both are byte-identical to the Rust lock
+ * (`src/import.rs` `write_rollup`, `src/drift.rs` `Declarations::write_into`) — the
+ * byte-parity lockstep two writers keep until single-writer lands.
+ *
+ * Fingerprints are SHA-256 hex over raw UTF-8 (`hash::sha256_hex`), so an
+ * SDK-emitted lock and a Rust-emitted lock agree for the same harness.
+ */
+import type { Projection } from "./project.js";
+import type { Declarations } from "./declarations.js";
+/** Lowercase hex SHA-256 of `text`'s UTF-8 bytes — the Rust `sha256_hex` port. */
+export declare function sha256Hex(text: string): string;
+/** One rollup row: a member's identity and the two freshness fingerprints. */
+export interface LockRow {
+    /** The bare kind name — the `[[<kind>]]` array key (`rule`, `skill`, `memory`). */
+    readonly kind: string;
+    /** The member id — its `[[<kind>]]` `name` column. */
+    readonly name: string;
+    /** The projection's harness path — the source-of-record the fingerprints anchor. */
+    readonly sourcePath: string;
+    /** SHA-256 of the authored source bytes (the projection, for a module-carried member). */
+    readonly sourceHash: string;
+    /** SHA-256 of the last emitted projection — the `config.stale` baseline. */
+    readonly emitHash: string;
+}
+/**
+ * The rollup row a projection stamps: both fingerprints are `sha256(projection
+ * bytes)`, the fresh-emit baseline (`source_hash == emit_hash`) a Rust import then
+ * emit lands on for a byte-identical projection.
+ */
+export declare function lockRow(kind: string, projection: Projection): LockRow;
+/**
+ * Serialize the lock — the rollup rows then the declaration families, joined the
+ * `toml_edit` way (exactly one blank line before every table header but the
+ * document's first). An all-empty declaration set contributes no sections, so a
+ * memberless lock is empty and a rollup-only lock carries no `[declaration]` rows.
+ */
+export declare function stampLock(rows: readonly LockRow[], declarations?: Declarations): string;