@dtmd/temper 0.0.2 → 0.0.3

package/dist/src/claude-code.d.ts

@@ -11,3 +11,5 @@
  */
 export type { Memory, Rule, Skill } from "./builtins.js";
 export { memory, rule, skill } from "./builtins.js";
+export type { Blocks, File, Prose, Text } from "./prose.js";
+export { blocks, file, text } from "./prose.js";

package/dist/src/claude-code.js

@@ -10,3 +10,4 @@
  * exist.
  */
 export { memory, rule, skill } from "./builtins.js";
+export { blocks, file, text } from "./prose.js";

package/dist/src/declarations.d.ts

@@ -42,14 +42,20 @@ 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;

package/dist/src/declarations.js

@@ -99,7 +99,18 @@ 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 = [];
@@ -118,6 +129,7 @@ export function compileDeclarations(harness) {
         clauses,
         requirements: requirementRows(harness),
         assembly: assemblyFactRows(harness, kinds),
+        satisfies: satisfiesRows(harness),
     };
 }
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */

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 {

package/dist/src/index.d.ts

@@ -4,9 +4,11 @@
  * A harness author imports plain nouns — `harness()`, the generic `kind`/`genre`
  * constructors, 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.
+ * whole into the declaration rows and the projected members' erased payload —
+ * the JSON pipe printed to stdout; the engine is the sole compiler of every
+ * projection and the whole lock (`20-surface.md`, "The seam — one
+ * implementation"). Every type erases at the seam, and Turing-completeness
+ * stays quarantined at authoring time.
  *
  * The first-party Claude Code provider face — the built-in `skill`/`rule`/
  * `memory` kinds — lives at the `./claude-code` subpath, never here
@@ -14,8 +16,8 @@
  */
 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 { GenreValue } from "./genres.js";
+export { genreValue } 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";
@@ -24,11 +26,7 @@ export type { EdgeField, Format, KindDefinition, KindFacts, Locus, Member, Membe
 export { genre, kind } from "./kind.js";
 export type { ExpectBinding, Harness } from "./assembly.js";
 export { harness } from "./assembly.js";
-export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, } from "./declarations.js";
+export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, SatisfiesRow, } 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";
+export type { EmitOptions, EmitResult, PayloadMember, ResolveOptions } from "./emit.js";
+export { emit } from "./emit.js";

package/dist/src/index.js

@@ -4,21 +4,21 @@
  * A harness author imports plain nouns — `harness()`, the generic `kind`/`genre`
  * constructors, 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.
+ * whole into the declaration rows and the projected members' erased payload —
+ * the JSON pipe printed to stdout; the engine is the sole compiler of every
+ * projection and the whole lock (`20-surface.md`, "The seam — one
+ * implementation"). Every type erases at the seam, and Turing-completeness
+ * stays quarantined at authoring time.
  *
  * The first-party Claude Code provider face — the built-in `skill`/`rule`/
  * `memory` kinds — lives at the `./claude-code` subpath, never here
  * (`specs/architecture/50-distribution.md`, "Decision: one SDK package").
  */
 export { blocks, file, renderText, text } from "./prose.js";
-export { bound, decision, genreValue, law } from "./genres.js";
+export { genreValue } 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 { 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";
+export { emit } from "./emit.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtmd/temper",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "The temper authoring face — the six-noun model as typed modules: harness(), kind<T>(), clause values, needs, and file()/text/blocks(). Emit compiles to the declaration rows the engine reads, a byte-faithful projection, and the lock.",
   "license": "(MIT OR Apache-2.0)",
   "repository": {

package/dist/src/lock.d.ts

@@ -1,43 +0,0 @@
-/**
- * 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;

package/dist/src/lock.js

@@ -1,127 +0,0 @@
-/**
- * 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 { createHash } from "node:crypto";
-import { joinSections, keyValue, encodeString } from "./toml.js";
-/** Lowercase hex SHA-256 of `text`'s UTF-8 bytes — the Rust `sha256_hex` port. */
-export function sha256Hex(text) {
-    return createHash("sha256").update(text, "utf8").digest("hex");
-}
-/** The member name a projection encodes — the path's identity segment. */
-function projectionName(projection) {
-    const segments = projection.path.split("/");
-    const last = segments[segments.length - 1];
-    if (last === "SKILL.md")
-        return segments[segments.length - 2];
-    return last.replace(/\.md$/, "");
-}
-/**
- * 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 function lockRow(kind, projection) {
-    const hash = sha256Hex(projection.bytes);
-    return {
-        kind,
-        name: projectionName(projection),
-        sourcePath: projection.path,
-        sourceHash: hash,
-        emitHash: hash,
-    };
-}
-/** The rollup sections — one `[[<kind>]]` table per member, kinds then rows name-sorted. */
-function rollupSections(rows) {
-    const byKind = new Map();
-    for (const row of rows) {
-        const bucket = byKind.get(row.kind);
-        if (bucket)
-            bucket.push(row);
-        else
-            byKind.set(row.kind, [row]);
-    }
-    const sections = [];
-    for (const kind of [...byKind.keys()].sort()) {
-        const kindRows = byKind
-            .get(kind)
-            .slice()
-            .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-        for (const row of kindRows) {
-            sections.push(`[[${kind}]]\n` +
-                keyValue("name", encodeString(row.name)) +
-                keyValue("source_path", encodeString(row.sourcePath)) +
-                keyValue("source_hash", encodeString(row.sourceHash)) +
-                keyValue("emit_hash", encodeString(row.emitHash)));
-        }
-    }
-    return sections;
-}
-/** A `key = "value"\n` line for a present string column, or "" to omit an absent one. */
-function optionalColumn(key, value) {
-    return value === undefined ? "" : keyValue(key, encodeString(value));
-}
-/**
- * The `[declaration]` table's sections, in the fixed family order kind · clause ·
- * requirement · assembly, each row a `[[declaration.<family>]]` table with its
- * columns in the Rust `to_table` order. An empty family writes nothing — an empty
- * array vanishes on the toml round-trip.
- */
-function declarationSections(declarations) {
-    const sections = [];
-    for (const row of declarations.kinds) {
-        sections.push("[[declaration.kind]]\n" +
-            keyValue("name", encodeString(row.name)) +
-            optionalColumn("provider", row.provider) +
-            keyValue("governs_root", encodeString(row.governs_root)) +
-            keyValue("governs_glob", encodeString(row.governs_glob)) +
-            optionalColumn("format", row.format) +
-            optionalColumn("unit_shape", row.unit_shape) +
-            optionalColumn("activation", row.activation));
-    }
-    for (const row of declarations.clauses) {
-        sections.push("[[declaration.clause]]\n" +
-            keyValue("kind", encodeString(row.kind)) +
-            keyValue("predicate", encodeString(row.predicate)) +
-            optionalColumn("field", row.field) +
-            keyValue("severity", encodeString(row.severity)));
-    }
-    for (const row of declarations.requirements) {
-        sections.push("[[declaration.requirement]]\n" +
-            keyValue("name", encodeString(row.name)) +
-            optionalColumn("kind", row.kind) +
-            optionalColumn("package", row.package) +
-            keyValue("required", row.required ? "true" : "false") +
-            optionalColumn("verified_by", row.verified_by));
-    }
-    for (const row of declarations.assembly) {
-        sections.push("[[declaration.assembly]]\n" +
-            keyValue("fact", encodeString(row.fact)) +
-            optionalColumn("value", row.value) +
-            optionalColumn("from", row.from) +
-            optionalColumn("field", row.field) +
-            optionalColumn("to", row.to));
-    }
-    return sections;
-}
-/**
- * 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 function stampLock(rows, declarations) {
-    const sections = [...rollupSections(rows)];
-    if (declarations !== undefined)
-        sections.push(...declarationSections(declarations));
-    return joinSections(sections);
-}

package/dist/src/project.d.ts

@@ -1,79 +0,0 @@
-/**
- * Projection — emit compiles each member to its harness format under `.claude/**`,
- * whole-file and byte-faithful (`specs/architecture/20-surface.md`, "Emit —
- * total"). A member with frontmatter fields projects to a fresh `---`-delimited
- * block over its resolved body; a frontmatterless kind (memory) projects to its
- * body alone. The words are the author's, untouched — emit never stamps metadata
- * into the projection (law 5); the managed-by note and the schema modeline ride
- * `install`, and a re-emit round-trips them through the whole-file write.
- *
- * The locus and layout come from the kind's five facts (`15-kinds.md`), never a
- * hardcoded kind name: a directory unit lands its entry file under a per-member
- * directory, a lone file lands at the stem, a frontmatterless any-depth memory
- * lands the root `<name>.md`.
- */
-import type { KindFacts } from "./kind.js";
-/** One projected harness file: where it lands and the byte-faithful content. */
-export interface Projection {
-    /** The slash path relative to the harness root (`.claude/**`, or a root memory). */
-    readonly path: string;
-    /** The whole-file projection bytes — frontmatter (if any) over the body. */
-    readonly bytes: string;
-}
-/** The resolved member emit hands the projector — facts, name, ordered fields, resolved body. */
-export interface ProjectionInput {
-    readonly facts: KindFacts;
-    readonly name: string;
-    readonly fields: ReadonlyArray<readonly [string, unknown]>;
-    readonly body: string;
-}
-/** Emit-time inputs beyond the member — where install's placements are read from. */
-export interface ProjectOptions {
-    /**
-     * The harness root the **committed** projection is read from to carry install's
-     * frontmatter placements (the schema modeline + managed-by note) through the
-     * whole-file re-emit — the two-projectors seam. Absent — or an absent committed
-     * file — carries no placements: emit writes the projection fresh.
-     */
-    readonly projectionDir?: string;
-}
-/**
- * The install-placed frontmatter comment lines present in `source`, in on-disk
- * order — the schema modeline and the managed-by note. `emit` round-trips these
- * through its whole-file re-emit so its content-faithful projection (law 5)
- * carries install's metadata instead of dropping it (`20-surface.md`).
- */
-export declare function placementLines(source: string): string[];
-/**
- * The harness locus a member of `facts` named `name` projects onto, derived from
- * the kind's locus and unit shape (`15-kinds.md`): a directory unit lands its
- * entry file under `<root>/<name>/`; a lone file replaces the glob's `*` with the
- * name (an any-depth memory lands the root `<name>.md`).
- *
- * # Throws
- * If the kind is a genre — a block-locus member has no standalone projection.
- */
-export declare function projectionPath(facts: KindFacts, name: string): string;
-/**
- * One frontmatter field as `key: <value>\n`, or `null` to omit a null/undefined
- * value. The value is compact JSON — valid YAML flow, round-tripping to the same
- * JSON on the next parse — matching the Rust `render_field` (`serde_json::to_string`).
- */
-export declare function renderField(key: string, value: unknown): string | null;
-/**
- * The whole-file projection bytes for one member: no surviving field ⇒ the body
- * alone (no frontmatter block, so no place a modeline/note could sit); one or
- * more ⇒ a fresh `---` frontmatter (install's preserved `placements` first, then
- * every field in order) over the byte-faithful body.
- */
-export declare function projectBytes(fields: ReadonlyArray<readonly [string, unknown]>, body: string, placements?: readonly string[]): string;
-/**
- * Project one resolved member onto its harness file — its locus and the whole-file
- * bytes. With `options.projectionDir` set, install's placement lines ride through
- * the re-emit (the two-projectors seam).
- *
- * # Throws
- * If the member's kind is a genre ([`projectionPath`]), or the committed projection
- * cannot be read for a reason other than absence.
- */
-export declare function projectMember(member: ProjectionInput, options?: ProjectOptions): Projection;

package/dist/src/project.js

@@ -1,162 +0,0 @@
-/**
- * Projection — emit compiles each member to its harness format under `.claude/**`,
- * whole-file and byte-faithful (`specs/architecture/20-surface.md`, "Emit —
- * total"). A member with frontmatter fields projects to a fresh `---`-delimited
- * block over its resolved body; a frontmatterless kind (memory) projects to its
- * body alone. The words are the author's, untouched — emit never stamps metadata
- * into the projection (law 5); the managed-by note and the schema modeline ride
- * `install`, and a re-emit round-trips them through the whole-file write.
- *
- * The locus and layout come from the kind's five facts (`15-kinds.md`), never a
- * hardcoded kind name: a directory unit lands its entry file under a per-member
- * directory, a lone file lands at the stem, a frontmatterless any-depth memory
- * lands the root `<name>.md`.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-/** The schema modeline marker install places and emit preserves (`src/install.rs`). */
-const MODELINE_MARKER = "# yaml-language-server:";
-/** The managed-by note's stable marker (`src/install.rs`). */
-const NOTE_MARKER = "# temper: managed projection";
-/** Whether `line` is one of install's managed metadata comments. */
-function isPlacementComment(line) {
-    const trimmed = line.replace(/^\s+/, "");
-    return trimmed.startsWith(MODELINE_MARKER) || trimmed.startsWith(NOTE_MARKER);
-}
-/**
- * A string's lines the Rust `str::lines` way: split on `\n`, a trailing newline
- * opens no line, a trailing `\r` is stripped from each.
- */
-function lines(textValue) {
-    if (textValue === "")
-        return [];
-    const parts = textValue.split("\n");
-    if (parts[parts.length - 1] === "")
-        parts.pop();
-    return parts.map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
-}
-/**
- * The frontmatter interior of `rest` — everything after the opening `---\n` up to
- * the closing `---` line — or `null` when there is no closing delimiter (an
- * opening `---` that is really prose). A port of the Rust `install::frontmatter_inner`.
- */
-function frontmatterInner(rest) {
-    let offset = 0;
-    let cursor = 0;
-    while (cursor < rest.length) {
-        const newline = rest.indexOf("\n", cursor);
-        const end = newline === -1 ? rest.length : newline + 1;
-        const piece = rest.slice(cursor, end);
-        const content = piece.endsWith("\n") ? piece.slice(0, -1) : piece;
-        if (content.replace(/\s+$/, "") === "---")
-            return rest.slice(0, offset);
-        offset += piece.length;
-        cursor = end;
-    }
-    return null;
-}
-/**
- * The install-placed frontmatter comment lines present in `source`, in on-disk
- * order — the schema modeline and the managed-by note. `emit` round-trips these
- * through its whole-file re-emit so its content-faithful projection (law 5)
- * carries install's metadata instead of dropping it (`20-surface.md`).
- */
-export function placementLines(source) {
-    if (!source.startsWith("---\n"))
-        return [];
-    const inner = frontmatterInner(source.slice("---\n".length));
-    if (inner === null)
-        return [];
-    return lines(inner).filter(isPlacementComment);
-}
-/** Join non-empty, non-`.` path segments with `/` — a `.` root drops out (root memory). */
-function joinSlash(...parts) {
-    return parts.filter((part) => part !== "" && part !== ".").join("/");
-}
-/**
- * The harness locus a member of `facts` named `name` projects onto, derived from
- * the kind's locus and unit shape (`15-kinds.md`): a directory unit lands its
- * entry file under `<root>/<name>/`; a lone file replaces the glob's `*` with the
- * name (an any-depth memory lands the root `<name>.md`).
- *
- * # Throws
- * If the kind is a genre — a block-locus member has no standalone projection.
- */
-export function projectionPath(facts, name) {
-    if (facts.locus.kind !== "at") {
-        throw new Error(`kind \`${facts.name}\` is a genre — its members live inside host documents ` +
-            `and have no standalone projection (specs/architecture/15-kinds.md).`);
-    }
-    const { root, glob } = facts.locus;
-    if (facts.unitShape === "directory") {
-        // `*/SKILL.md` → the entry file after the first slash, under a per-member dir.
-        const entry = glob.slice(glob.indexOf("/") + 1);
-        return joinSlash(root, name, entry);
-    }
-    // A lone file: any-depth glob (`**/CLAUDE.md`) is the root `<name>.md`; a simple
-    // glob (`*.md`) replaces its single star with the name.
-    const filename = glob.includes("**") ? `${name}.md` : glob.replace("*", name);
-    return joinSlash(root, filename);
-}
-/**
- * One frontmatter field as `key: <value>\n`, or `null` to omit a null/undefined
- * value. The value is compact JSON — valid YAML flow, round-tripping to the same
- * JSON on the next parse — matching the Rust `render_field` (`serde_json::to_string`).
- */
-export function renderField(key, value) {
-    if (value === null || value === undefined)
-        return null;
-    return `${key}: ${JSON.stringify(value)}\n`;
-}
-/**
- * The whole-file projection bytes for one member: no surviving field ⇒ the body
- * alone (no frontmatter block, so no place a modeline/note could sit); one or
- * more ⇒ a fresh `---` frontmatter (install's preserved `placements` first, then
- * every field in order) over the byte-faithful body.
- */
-export function projectBytes(fields, body, placements = []) {
-    const rendered = fields
-        .map(([key, value]) => renderField(key, value))
-        .filter((line) => line !== null);
-    if (rendered.length === 0)
-        return body;
-    const frontmatter = placements.map((line) => `${line}\n`).join("") + rendered.join("");
-    return `---\n${frontmatter}---\n${body}`;
-}
-/**
- * Read the install-placed frontmatter lines from the committed projection at
- * `projectionDir/path`, or `[]` when none is read (no `projectionDir`, or the file
- * is absent — emit writes it fresh). Reads are of committed bytes, never a clock,
- * so the double-emit purity check still holds.
- *
- * # Throws
- * On a read failure that is not "file absent".
- */
-function committedPlacements(projectionDir, path) {
-    if (projectionDir === undefined)
-        return [];
-    try {
-        return placementLines(readFileSync(join(projectionDir, path), "utf8"));
-    }
-    catch (cause) {
-        if (cause.code === "ENOENT")
-            return [];
-        throw new Error(`failed to read committed projection \`${path}\` under \`${projectionDir}\`.`, {
-            cause,
-        });
-    }
-}
-/**
- * Project one resolved member onto its harness file — its locus and the whole-file
- * bytes. With `options.projectionDir` set, install's placement lines ride through
- * the re-emit (the two-projectors seam).
- *
- * # Throws
- * If the member's kind is a genre ([`projectionPath`]), or the committed projection
- * cannot be read for a reason other than absence.
- */
-export function projectMember(member, options = {}) {
-    const path = projectionPath(member.facts, member.name);
-    const placements = committedPlacements(options.projectionDir, path);
-    return { path, bytes: projectBytes(member.fields, member.body, placements) };
-}

package/dist/src/toml.d.ts

@@ -1,26 +0,0 @@
-/**
- * TOML value/key encoding and table layout — a faithful port of `toml_write`
- * 0.1.2 (`src/string.rs`) and `toml_edit` 0.22.27's `visit_table`
- * (`specs/architecture/20-surface.md`, "Content-faithful, deterministically
- * emitted (law 5)"). Shared by the manifest emitter (`emit.ts`) and the lock
- * stamper (`lock.ts`) so every `key = value` line and every table header the SDK
- * writes is byte-identical to the Rust `toml_edit` output — the manifest, the
- * projection frontmatter, and the lock all agree to the byte.
- */
-/** A TOML string *value* — the exact bytes `toml_edit`'s `value(String)` emits. */
-export declare function encodeString(s: string): string;
-/** A TOML *key* — bare where it can be, else `toml_edit`'s `TomlKeyBuilder::as_default`. */
-export declare function encodeKey(s: string): string;
-/** One `key = value\n` line, the key/value decor `toml_edit` renders (`key = value`). */
-export declare function keyValue(key: string, valueRepr: string): string;
-/** A TOML string array — `["a", "b"]`, no leading space, `, ` between elements. */
-export declare function stringArray(values: readonly string[]): string;
-/** Sorted keys — the stable order `toml_edit` gets for free from its `BTreeMap`s. */
-export declare function sortedKeys(record: Readonly<Record<string, unknown>>): string[];
-/**
- * Join an ordered list of table sections the `toml_edit` way — exactly one blank
- * line before every table header but the document's first
- * (`DEFAULT_TABLE_DECOR = ("\n", "")`, the first table `("", …)`). Each section is
- * a header line plus its `key = value\n` lines, already newline-terminated.
- */
-export declare function joinSections(sections: readonly string[]): string;

package/dist/src/toml.js

@@ -1,194 +0,0 @@
-/**
- * TOML value/key encoding and table layout — a faithful port of `toml_write`
- * 0.1.2 (`src/string.rs`) and `toml_edit` 0.22.27's `visit_table`
- * (`specs/architecture/20-surface.md`, "Content-faithful, deterministically
- * emitted (law 5)"). Shared by the manifest emitter (`emit.ts`) and the lock
- * stamper (`lock.ts`) so every `key = value` line and every table header the SDK
- * writes is byte-identical to the Rust `toml_edit` output — the manifest, the
- * projection frontmatter, and the lock all agree to the byte.
- */
-/** `ValueMetrics::calculate` — the run-length and escape facts style choice reads. */
-function stringMetrics(s) {
-    let maxSingle = 0;
-    let maxDouble = 0;
-    let escapeCodes = false;
-    let escape = false;
-    let newline = false;
-    let prevSingle = 0;
-    let prevDouble = 0;
-    for (const ch of s) {
-        const cp = ch.codePointAt(0);
-        if (cp === 0x27) {
-            prevSingle += 1;
-            maxSingle = Math.max(maxSingle, prevSingle);
-        }
-        else {
-            prevSingle = 0;
-        }
-        if (cp === 0x22) {
-            prevDouble += 1;
-            maxDouble = Math.max(maxDouble, prevDouble);
-        }
-        else {
-            prevDouble = 0;
-        }
-        // The arm order mirrors the Rust match: `\` then `\t` (allowed) then `\n`
-        // then the general control range.
-        if (cp === 0x5c)
-            escape = true;
-        else if (cp === 0x09) {
-            /* horizontal tab is always allowed — neutral */
-        }
-        else if (cp === 0x0a)
-            newline = true;
-        else if (cp <= 0x1f || cp === 0x7f)
-            escapeCodes = true;
-    }
-    return { maxSingle, maxDouble, escapeCodes, escape, newline };
-}
-/** `TomlStringBuilder::as_default` — the fall-through style preference. */
-function chooseEncoding(m) {
-    // as_basic_pretty
-    if (!(m.escapeCodes || m.escape || m.maxDouble > 0 || m.newline))
-        return "basic";
-    // as_literal
-    if (!(m.escapeCodes || m.maxSingle > 0 || m.newline))
-        return "literal";
-    // as_ml_basic_pretty
-    if (!(m.escapeCodes || m.escape || m.maxDouble > 2))
-        return "mlbasic";
-    // as_ml_literal
-    if (!(m.escapeCodes || m.maxSingle > 2))
-        return "mlliteral";
-    // fallback: the escaped forms
-    return m.newline ? "mlbasic" : "basic";
-}
-/** The basic/multiline-basic escaper from `write_toml_value` (the `escaped` branch). */
-function escapeBasic(s, isMl) {
-    const maxSeqDouble = isMl ? 2 : 0;
-    let out = "";
-    let seqDouble = 0;
-    for (const ch of s) {
-        const cp = ch.codePointAt(0);
-        if (cp === 0x22) {
-            seqDouble += 1;
-            if (seqDouble > maxSeqDouble) {
-                out += '\\"';
-                seqDouble = 0;
-                continue;
-            }
-            out += '"';
-            continue;
-        }
-        seqDouble = 0;
-        switch (cp) {
-            case 0x08:
-                out += "\\b";
-                break;
-            case 0x09:
-                out += "\\t";
-                break;
-            case 0x0a:
-                // A literal newline survives inside a multiline string; a basic string
-                // escapes it.
-                out += isMl ? "\n" : "\\n";
-                break;
-            case 0x0c:
-                out += "\\f";
-                break;
-            case 0x0d:
-                out += "\\r";
-                break;
-            case 0x5c:
-                out += "\\\\";
-                break;
-            default:
-                if (cp <= 0x1f || cp === 0x7f) {
-                    out += "\\u" + cp.toString(16).toUpperCase().padStart(4, "0");
-                }
-                else {
-                    out += ch;
-                }
-        }
-    }
-    return out;
-}
-/** A TOML string *value* — the exact bytes `toml_edit`'s `value(String)` emits. */
-export function encodeString(s) {
-    const m = stringMetrics(s);
-    const enc = chooseEncoding(m);
-    const delimiter = enc === "literal" ? "'" : enc === "basic" ? '"' : enc === "mlliteral" ? "'''" : '"""';
-    const isMl = enc === "mlliteral" || enc === "mlbasic";
-    const escaped = enc === "basic" || enc === "mlbasic";
-    let out = delimiter;
-    if (m.newline && isMl)
-        out += "\n";
-    out += escaped ? escapeBasic(s, isMl) : s;
-    out += delimiter;
-    return out;
-}
-/** `KeyMetrics::calculate` — whether a key may be bare, and its escape facts. */
-function keyMetrics(s) {
-    let unquoted = s.length > 0;
-    let single = false;
-    let double = false;
-    let escapeCodes = false;
-    let escape = false;
-    for (const ch of s) {
-        const cp = ch.codePointAt(0);
-        const wordByte = (cp >= 0x61 && cp <= 0x7a) ||
-            (cp >= 0x41 && cp <= 0x5a) ||
-            (cp >= 0x30 && cp <= 0x39) ||
-            cp === 0x2d ||
-            cp === 0x5f;
-        if (!wordByte)
-            unquoted = false;
-        if (cp === 0x27)
-            single = true;
-        else if (cp === 0x22)
-            double = true;
-        else if (cp === 0x5c)
-            escape = true;
-        else if (cp === 0x09) {
-            /* tab allowed */
-        }
-        else if (cp <= 0x1f || cp === 0x7f)
-            escapeCodes = true;
-    }
-    return { unquoted, single, double, escapeCodes, escape };
-}
-/** A TOML *key* — bare where it can be, else `toml_edit`'s `TomlKeyBuilder::as_default`. */
-export function encodeKey(s) {
-    const m = keyMetrics(s);
-    if (m.unquoted)
-        return s;
-    // as_basic_pretty
-    if (!(m.escapeCodes || m.escape || m.double))
-        return '"' + escapeBasic(s, false) + '"';
-    // as_literal
-    if (!(m.escapeCodes || m.single))
-        return "'" + s + "'";
-    // as_basic (fallback)
-    return '"' + escapeBasic(s, false) + '"';
-}
-/** One `key = value\n` line, the key/value decor `toml_edit` renders (`key = value`). */
-export function keyValue(key, valueRepr) {
-    return `${encodeKey(key)} = ${valueRepr}\n`;
-}
-/** A TOML string array — `["a", "b"]`, no leading space, `, ` between elements. */
-export function stringArray(values) {
-    return "[" + values.map(encodeString).join(", ") + "]";
-}
-/** Sorted keys — the stable order `toml_edit` gets for free from its `BTreeMap`s. */
-export function sortedKeys(record) {
-    return Object.keys(record).sort();
-}
-/**
- * Join an ordered list of table sections the `toml_edit` way — exactly one blank
- * line before every table header but the document's first
- * (`DEFAULT_TABLE_DECOR = ("\n", "")`, the first table `("", …)`). Each section is
- * a header line plus its `key = value\n` lines, already newline-terminated.
- */
-export function joinSections(sections) {
-    return sections.map((section, i) => (i === 0 ? "" : "\n") + section).join("");
-}