@dtmd/temper 0.0.2 → 0.0.4

package/dist/src/declarations.d.ts

@@ -9,6 +9,7 @@
  * ({@link declarationsToJson}) — 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;
@@ -17,24 +18,68 @@ export interface KindFactRow {
     readonly governs_glob: string;
     readonly format?: string;
     readonly unit_shape?: string;
-    readonly activation?: string;
+    readonly registration?: string;
 }
-/** One clause of a kind's effective contract, reduced to the lock's columns. */
+/**
+ * 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").
+ */
 export interface ClauseRow {
-    readonly kind: string;
+    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[];
 }
-/** One named requirement's declaration row, reduced to the scalar facets the lock records. */
+/**
+ * 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.
+ */
 export interface RequirementRow {
     readonly name: string;
     readonly kind?: string;
-    readonly package?: string;
     readonly required: boolean;
+    readonly clauses: readonly ClauseRow[];
     readonly verified_by?: string;
 }
-/** One assembly-scope fact — authority, reachability, or an edge. */
+/** One assembly-scope fact — authority or an edge. */
 export interface AssemblyFactRow {
     readonly fact: string;
     readonly value?: string;
@@ -42,17 +87,23 @@ export interface AssemblyFactRow {
     readonly field?: string;
     readonly to?: string;
 }
-/** The four declaration families — the whole erased program the lock and pipe carry. */
+/** 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 four declaration families — the erased program. */
+/** Compile a harness into its five 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;
+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

package/dist/src/declarations.js

@@ -8,8 +8,65 @@
  * (`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) {
+/**
+ * Compile one `Clause` into its lock row: the shared `key`/`field`/`severity`/
+ * `guidance`/`cite` columns — the clause's four channels surviving erasure
+ * (`10-contracts.md`, "The clause — the atom of a contract") — plus, when the
+ * predicate carries them, the `count`/`target`/`degree` argument columns a
+ * requirement's own set-/edge-scope demand needs (`10-contracts.md`, "Judged
+ * at the node-set scope" / "Judged at the edge scope"), and the
+ * `bound`/`charset`/`keys`/`values` argument columns a kind's own node-scope
+ * floor clause needs (`min_len`/`max_len`/`max_lines`'s bound,
+ * `allowed_chars`'s charset, `forbidden_keys`'s keys, `deny`'s values) — so
+ * the lock encodes the floor losslessly, not identity+severity alone. `kind`
+ * is supplied only for a kind's own `expect` clause; a requirement's nested
+ * clause carries none.
+ */
+function clauseRow(clause, kind) {
+    const { predicate } = clause;
+    return {
+        kind,
+        predicate: predicate.key,
+        field: predicate.field,
+        severity: clause.severity,
+        guidance: clause.guidance,
+        cite: clause.cite,
+        count: predicate.key === "count"
+            ? { min: predicate.args?.min ?? 0, max: predicate.args?.max ?? Number.MAX_SAFE_INTEGER }
+            : undefined,
+        target: predicate.key === "membership" ? predicate.target : undefined,
+        degree: predicate.key === "degree"
+            ? {
+                incoming: edgeBoundArgs(predicate.args, "incoming"),
+                outgoing: edgeBoundArgs(predicate.args, "outgoing"),
+            }
+            : undefined,
+        bound: nodeScopeBoundArgs(predicate),
+        charset: predicate.key === "allowed_chars" ? predicate.charset : undefined,
+        keys: predicate.key === "forbidden_keys" ? predicate.keys : undefined,
+        values: predicate.key === "deny" ? predicate.values : undefined,
+    };
+}
+/** `min_len`/`max_len`/`max_lines`'s scalar bound off their shared `min`/`max`
+ * args keys — `undefined` for every other predicate, and for these three when
+ * neither endpoint is present. */
+function nodeScopeBoundArgs(predicate) {
+    if (predicate.key !== "min_len" && predicate.key !== "max_len" && predicate.key !== "max_lines") {
+        return undefined;
+    }
+    const min = predicate.args?.min;
+    const max = predicate.args?.max;
+    return min === undefined && max === undefined ? undefined : { min, max };
+}
+/** One `degree` direction's `{min, max}` off its flat `<dir>_min`/`<dir>_max` args
+ * keys — `undefined` when neither is present (that direction is unconstrained). */
+function edgeBoundArgs(args, direction) {
+    const min = args?.[`${direction}_min`];
+    const max = args?.[`${direction}_max`];
+    return min === undefined && max === undefined ? undefined : { min, max };
+}
+/** The lock label for a kind's declared registration. */
+function registrationLabel(registration) {
     switch (registration.via) {
         case "always":
             return "always";
@@ -38,7 +95,7 @@ function kindFactRow(facts) {
         governs_glob: facts.locus.glob,
         format: facts.format,
         unit_shape: facts.unitShape,
-        activation: activationLabel(facts.registration),
+        registration: registrationLabel(facts.registration),
     };
 }
 /** The distinct locus-bearing kinds in play — member kinds ∪ expect kinds, name-sorted. */
@@ -78,20 +135,18 @@ function requirementRows(harness) {
         name,
         kind: requirement.kind?.key,
         required: requirement.required ?? false,
+        clauses: (requirement.clauses ?? []).map((clause) => clauseRow(clause)),
         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`).
+ * authored), then one edge row per kind edge field (`40-composition.md`;
+ * `45-governance.md`).
  */
-function assemblyFactRows(harness, kinds) {
+function assemblyFactRows(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 });
@@ -99,29 +154,36 @@ function assemblyFactRows(harness, kinds) {
     }
     return facts;
 }
-/** Compile a harness into its four declaration families — the erased program. */
+/** The `satisfies` rows — every member's fill claims, member-then-requirement sorted. */
+function satisfiesRows(harness) {
+    const rows = [];
+    for (const member of harness.members) {
+        for (const requirement of member.satisfies) {
+            rows.push({ member: member.name, requirement });
+        }
+    }
+    return rows.sort((a, b) => (a.member < b.member ? -1 : a.member > b.member ? 1 : 0) ||
+        (a.requirement < b.requirement ? -1 : a.requirement > b.requirement ? 1 : 0));
+}
+/** Compile a harness into its five 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,
-            });
+            clauses.push(clauseRow(clause, binding.kind.key));
         }
     }
     return {
         kinds: kinds.map(kindFactRow),
         clauses,
         requirements: requirementRows(harness),
-        assembly: assemblyFactRows(harness, kinds),
+        assembly: assemblyFactRows(kinds),
+        satisfies: satisfiesRows(harness),
     };
 }
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */
-export const SEAM_VERSION = 1;
+export 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

package/dist/src/emit.d.ts

@@ -1,15 +1,15 @@
 /**
- * Emit — the compile from the six-noun face to the committed seam
+ * Emit — the compile from the six-noun face to the seam's JSON pipe
  * (`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).
+ * produces plain data — the declaration rows the engine reads and, per projected
+ * member, its ordered typed fields and resolved prose body. The engine is the
+ * sole compiler of every projection and the whole lock; the SDK writes neither.
+ * Emit is total (members are the only source), refuses before it produces 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 {
@@ -18,31 +18,38 @@ export interface ResolveOptions {
     /** 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. */
+/** One projected member's erased payload — the engine derives its locus from the kind's own declaration row. */
+export interface PayloadMember {
+    /** The kind's bare name — joins the payload's `declarations.kinds` family. */
+    readonly kind: string;
+    /** Identity within the kind. */
+    readonly name: string;
+    /** The kind's typed fields, flat and ordered — the projected frontmatter. */
+    readonly fields: ReadonlyArray<readonly [string, unknown]>;
+    /** The resolved prose body, byte-faithful. */
+    readonly body: string;
+    /** The resolved `file()` asset's absolute path; absent for `text`/`blocks` prose. */
+    readonly source_path?: string;
+}
+/** Emit-time inputs beyond the harness — where a `file()` asset's module-relative path resolves against. */
 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.
+ * A full emit's compiled outputs — the whole seam the engine reads
+ * (`20-surface.md`, "The seam"). A pure function of the harness, so [`emit`]
+ * double-verifies it.
  */
 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. */
+    /** The declaration rows — the erased program the lock's five families carry. */
     readonly declarations: Declarations;
-    /** The internal versioned JSON pipe to the engine — not a designed IR. */
+    /** The projected members — the engine's sole input for every projection. */
+    readonly members: readonly PayloadMember[];
+    /**
+     * The internal versioned JSON pipe to the engine — not a designed IR. The
+     * SDK's whole output surface: printed to stdout, never written to a file.
+     */
     readonly seam: string;
     /**
      * The derived permission list — the union of every member's `needs`, deduped and
@@ -53,18 +60,10 @@ export interface EmitResult {
     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
+ * Compile the whole face in one deterministic pass: the declaration rows (its
+ * rollup and its five families) and every projected member's erased payload.
+ * 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;

package/dist/src/emit.js

@@ -1,20 +1,19 @@
 /**
- * Emit — the compile from the six-noun face to the committed seam
+ * Emit — the compile from the six-noun face to the seam's JSON pipe
  * (`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).
+ * produces plain data — the declaration rows the engine reads and, per projected
+ * member, its ordered typed fields and resolved prose body. The engine is the
+ * sole compiler of every projection and the whole lock; the SDK writes neither.
+ * Emit is total (members are the only source), refuses before it produces 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 { resolve as resolvePath } from "node:path";
+import { readFileSync } from "node:fs";
 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";
+import { SEAM_VERSION, compileDeclarations } 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
@@ -30,7 +29,7 @@ function resolveBody(member, options) {
     if (prose === undefined)
         return "";
     if (prose.kind === "file") {
-        const assetPath = resolvePath(options.baseDir ?? process.cwd(), prose.path);
+        const assetPath = fileSourcePath(member, options);
         try {
             return readFileSync(assetPath, "utf8");
         }
@@ -71,7 +70,7 @@ function declaredAddresses(harness) {
     return set;
 }
 /**
- * The two declare-side refusals emit runs before it compiles a byte
+ * The two declare-side refusals emit runs before it produces 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).
@@ -115,23 +114,38 @@ function refuseBrokenSource(harness) {
 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) {
+/**
+ * The resolved absolute path of a `file()` prose asset, or `undefined` for
+ * `text`/`blocks` prose (or no prose) — the lift's own-path detection
+ * (`specs/architecture/20-surface.md`, "surface authority is a declared
+ * posture": the lock is what names a path a projection, so the engine needs
+ * each `file()` member's true source path to tell a lifted member's own file
+ * apart from a generated one).
+ */
+function fileSourcePath(member, options) {
+    const prose = member.prose;
+    if (prose?.kind !== "file")
+        return undefined;
+    return resolvePath(options.baseDir ?? process.cwd(), prose.path);
+}
+/** The harness's projected members as payload members, deterministically kind-then-name ordered. */
+function orderedMembers(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,
+        kind: member.kind,
         name: member.name,
         fields: member.fields,
         body: resolveBody(member, options),
+        source_path: fileSourcePath(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
+ * Compile the whole face in one deterministic pass: the declaration rows (its
+ * rollup and its five families) and every projected member's erased payload.
+ * 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).
  */
@@ -142,46 +156,20 @@ export function emit(harness, options = {}) {
         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 members = orderedMembers(harness, resolve);
         const declarations = compileDeclarations(harness);
         return {
-            projections,
-            lock: stampLock(rows, declarations),
             declarations,
-            seam: declarationsToJson(declarations),
+            members,
+            seam: JSON.stringify({ version: SEAM_VERSION, declarations, members }, null, 2) + "\n",
             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)) {
+    if (first.seam !== second.seam) {
         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

@@ -3,12 +3,14 @@
  * "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).
+ * This constructor carries the **shape only**: any predicate over a genre value
+ * is a clause some module ships, never here (`15-kinds.md`, the genre Decision).
+ * There is no prescribed genre ontology — a corpus that argues differently
+ * declares its own genres with the same machinery (`15-kinds.md`, "a genre is
+ * a full kind, and genre checks are data, never engine").
  *
- * They are the posture-3 spelling — fully composed values passed to `blocks()`
- * (`20-surface.md`). The byte-identical posture-2 fence render awaits
+ * `genreValue()` is the posture-3 spelling — a fully composed value passed to
+ * `blocks()` (`20-surface.md`). The byte-identical posture-2 fence render awaits
  * `(genre-fence-format)`, deferred until its first consumer lands.
  */
 /**
@@ -18,7 +20,7 @@
  * the leaf-address Decision).
  */
 export interface GenreValue {
-    /** The genre name — `decision`, `law`, `bound`, or a project's own. */
+    /** The genre name — a project's own, never a built-in prescribed ontology. */
     readonly genre: string;
     /** The value's key — the identity a leaf address carries (`surface-authority`). */
     readonly key: string;
@@ -27,35 +29,6 @@ export interface GenreValue {
     /** 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;

package/dist/src/genres.js

@@ -3,49 +3,16 @@
  * "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).
+ * This constructor carries the **shape only**: any predicate over a genre value
+ * is a clause some module ships, never here (`15-kinds.md`, the genre Decision).
+ * There is no prescribed genre ontology — a corpus that argues differently
+ * declares its own genres with the same machinery (`15-kinds.md`, "a genre is
+ * a full kind, and genre checks are data, never engine").
  *
- * They are the posture-3 spelling — fully composed values passed to `blocks()`
- * (`20-surface.md`). The byte-identical posture-2 fence render awaits
+ * `genreValue()` is the posture-3 spelling — a fully composed value 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 {