@dtmd/temper 0.0.4 → 0.0.6

package/dist/src/prose.d.ts

@@ -1,13 +1,15 @@
 /**
- * Prose — three constructors, one field type (`specs/architecture/20-surface.md`,
- * "Prose — three constructors, one field type"). A member's words are data the
+ * Prose — three constructors, one field type. A member's words are data the
  * member declares: `file()` for a document that keeps its medium, `` text`…` ``
- * for short inline prose, `blocks()` for fully composed genre values. Whatever
+ * for short inline prose, `blocks()` for fully composed embedded-member values. Whatever
  * the constructor, the words land byte-identical to their authored text (law 5).
- * Interpolations in `` text`…` `` are **mentions** — declared one-way edges,
- * authored per word, resolution-checked at emit, never mined (law 8).
+ * Interpolations in `` text`…` `` are references, two intents apart: a **mention**
+ * (a {@link Mentionable}) is a declared one-way edge that moves no content, and an
+ * **include** (an {@link Include}) pulls the target file's bytes into the host's emitted
+ * projection. Both are authored per word and resolution-checked at emit, never mined
+ * (law 8).
  */
-import type { GenreValue } from "./genres.js";
+import type { EmbeddedMemberValue } from "./kind.js";
 /** A declared value a mention may name — the target of the one-way citation edge. */
 export interface Mentionable {
     /** The mention's rendered form and graph edge target (`kind:name` or a leaf address). */
@@ -21,14 +23,32 @@ export interface Mention {
     readonly target: Mentionable;
 }
 /**
- * `file(path)` — the document keeps its medium: markdown in a markdown file,
- * full tooling, forever legal (posture 1, `15-kinds.md`). Resolved and read in
- * byte-for-byte at emit.
+ * An include the author interpolates into `` text`…` `` — it moves content, not a
+ * citation: at emit the engine pulls the target file's bytes into the host's projection
+ * at this slot and fingerprints the dependency. The path resolves against the stating
+ * module ({@link moduleUrl}), never the workspace — the same anchor {@link file} takes.
+ */
+export interface Include {
+    readonly kind: "include";
+    /** Path to the include target, resolved against {@link moduleUrl}. */
+    readonly path: string;
+    /** The declaring module's own `import.meta.url` — what {@link path} resolves against. */
+    readonly moduleUrl: string;
+}
+/** A `` text`…` `` interpolation — a mention (moves no content) or an include (moves content). */
+export type Reference = Mentionable | Include;
+/**
+ * `file(moduleUrl, path)` — the document keeps its medium: markdown in a
+ * markdown file, full tooling, forever legal (posture 1, `15-kinds.md`).
+ * Resolved and read in byte-for-byte at emit, relative to the declaring
+ * module, never the process cwd.
  */
 export interface File {
     readonly kind: "file";
-    /** Module-relative path to the authored document. */
+    /** Path to the authored document, resolved against {@link moduleUrl}. */
     readonly path: string;
+    /** The declaring module's own `import.meta.url` — what {@link path} resolves against. */
+    readonly moduleUrl: string;
 }
 /**
  * `` text`…` `` — short prose inline, dedented, byte-deterministic; the
@@ -37,38 +57,54 @@ export interface File {
  */
 export interface Text {
     readonly kind: "text";
-    /** The dedented authored text with one {@link MENTION_SLOT} per mention, in order. */
+    /**
+     * The dedented authored text with one {@link MENTION_SLOT} per mention and one
+     * {@link INCLUDE_SLOT} per include, each in authored order.
+     */
     readonly template: string;
     readonly mentions: readonly Mention[];
+    /** The includes riding beside the text, in authored order — one per {@link INCLUDE_SLOT}. */
+    readonly includes: readonly Include[];
 }
 /**
- * `blocks(…)` — fully composed genre values (posture 3): typed collections whose
- * emitted document is pure render, byte-identical to the same values authored as
- * fences (posture 2). The shared fence format is `(genre-fence-format)`, deferred
- * until its first consumer lands (`15-kinds.md`), so a `blocks()` body composes
- * now and renders when the pilot does — emit refuses to project one until then,
- * never guessing a format.
+ * `blocks(…)` — fully composed embedded-member values (posture 3): typed
+ * collections rendered to `member.<kind> <key>` TOML fences, byte-identical to
+ * the same values authored as fences directly (posture 2) and read back by the
+ * engine's fold (`src/extract.rs` `parse_embedded_info`/`parse_embedded_member`).
  */
 export interface Blocks {
     readonly kind: "blocks";
-    readonly values: readonly GenreValue[];
+    readonly values: readonly EmbeddedMemberValue[];
 }
 /** A member's prose — one of the three constructors, one field type. */
 export type Prose = File | Text | Blocks;
-/** Declare a document whose medium is preserved — read in whole at emit (posture 1). */
-export declare function file(path: string): File;
 /**
- * The inline dedenting prose constructor. Interpolate only {@link Mentionable}
- * values — each interpolation is a mention, opt-in per word; plain prose with
- * zero mentions is fully legal forever (the opt-in Decision, `20-surface.md`).
+ * Declare a document whose medium is preserved — read in whole at emit
+ * (posture 1). `moduleUrl` is the declaring module's own `import.meta.url`,
+ * so `path` resolves relative to that module, never the process cwd:
+ * `file(import.meta.url, "./long.md")`.
+ */
+export declare function file(moduleUrl: string, path: string): File;
+/**
+ * The inline dedenting prose constructor. Interpolate {@link Reference} values — a
+ * {@link Mentionable} is a mention (moves no content), an {@link Include} pulls the
+ * target's bytes in; either is opt-in per word, and plain prose with zero references is
+ * fully legal forever (the opt-in Decision, `20-surface.md`).
  *
  * # Throws
- * If an authored chunk contains {@link MENTION_SLOT} — the marker must be the
- * tool's alone, so a stray NUL is a loud authoring error, not a silent mis-split.
+ * If an authored chunk carries {@link MENTION_SLOT} or {@link INCLUDE_SLOT} — the markers
+ * are the tool's alone, so a stray one is a loud authoring error, not a silent mis-split.
  */
-export declare function text(strings: TemplateStringsArray, ...targets: Mentionable[]): Text;
-/** Compose fully-typed genre values into a member's body (posture 3). */
-export declare function blocks(...values: GenreValue[]): Blocks;
+export declare function text(strings: TemplateStringsArray, ...targets: Reference[]): Text;
+/**
+ * Declare an include target — its bytes are pulled into the host's projection at emit,
+ * a dependency the lock fingerprints. `moduleUrl` is the declaring module's own
+ * `import.meta.url`, so `path` resolves relative to that module, never the process cwd:
+ * `include(import.meta.url, "./fragment.md")`.
+ */
+export declare function include(moduleUrl: string, path: string): Include;
+/** Compose fully-typed embedded-member values into a member's body (posture 3). */
+export declare function blocks(...values: EmbeddedMemberValue[]): Blocks;
 /**
  * Render an inline body to its final text — the display rule applied: each
  * mention slot becomes its target's display form, the surrounding words
@@ -76,3 +112,14 @@ export declare function blocks(...values: GenreValue[]): Blocks;
  * construction, so the walk consumes every slot.
  */
 export declare function renderText(prose: Text): string;
+/**
+ * Resolve a leaf's authored value to its stored/rendered string: a bare string
+ * is unchanged; a `Text` leaf is mention-resolution-checked against
+ * `mentionable` (loud on a dangling address) and rendered by {@link renderText}
+ * — the same rule a member-level `Text` body resolves by. `context` prefixes
+ * the dangling-mention error so it names the leaf, not just the mention.
+ *
+ * # Throws
+ * If a mention names no declared value.
+ */
+export declare function resolveLeaf(value: string | Text, mentionable: ReadonlySet<string>, context: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtmd/temper",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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/genres.d.ts

@@ -1,38 +0,0 @@
-/**
- * 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.
- * 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").
- *
- * `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.
- */
-/**
- * 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 — 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;
-    /** 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 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

@@ -1,24 +0,0 @@
-/**
- * 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.
- * 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").
- *
- * `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.
- */
-/** 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 ?? {},
-    };
-}