@4fu/arbor-prompt 0.0.0-stage → 0.1.0

package/build.js

@@ -0,0 +1,247 @@
+/**
+ * Block builders: the one place a block is constructed
+ * (docs/prompting.md#blocks-and-the-renderer).
+ *
+ * No component writes prompt text; it hands the renderer blocks. These
+ * builders are the shapes the core, the tools and the plugins use, so a block
+ * of one kind is always built the same way.
+ */
+import { textOf } from "./text.js";
+import { formatTime } from "./time.js";
+/** One task, as it would open a window (docs/prompting.md#deliveries). */
+export function taskBlock(task) {
+    return {
+        kind: "task",
+        fields: {
+            ref: task.ref,
+            kind: task.kind,
+            reason: task.reason,
+            time: formatTime(task.time),
+            targets: [...task.targets],
+            ...(task.source === undefined ? {} : { source: task.source }),
+            ...(task.content === undefined ? {} : { content: [...task.content] }),
+        },
+    };
+}
+/** One line on the board (docs/coordination.md#the-board). */
+export function boardLineBlock(line) {
+    return {
+        kind: "board_line",
+        fields: {
+            window: line.window,
+            state: line.state,
+            doing: line.doing,
+            targets: [...line.targets],
+            used: line.used,
+            limit: line.limit,
+            ...(line.expects === undefined || line.expects.length === 0 ? {} : { expects: [...line.expects] }),
+        },
+    };
+}
+/** The cost of ending a window with unfinished work. */
+export function handoffBlock(handoff) {
+    return {
+        kind: "handoff",
+        fields: {
+            topics: [...handoff.topics],
+            progress: [...handoff.progress],
+            pending: [...handoff.pending],
+            agreements: [...handoff.agreements],
+            refs: [...handoff.refs],
+        },
+    };
+}
+/** A note's body, as data (docs/memory.md#notes). */
+export function noteBlock(note) {
+    return {
+        kind: "note",
+        fields: {
+            ref: note.ref,
+            title: note.title,
+            summary: note.summary,
+            revision: note.revision,
+            status: note.status,
+            ...(note.body === null ? {} : { body: [dataBlock(note.body)] }),
+        },
+    };
+}
+/** A note's summary, for lists and the memory snapshot. */
+export function noteSummaryBlock(note) {
+    return {
+        kind: "note_summary",
+        fields: {
+            ref: note.ref,
+            title: note.title,
+            summary: note.summary,
+            revision: note.revision,
+            status: note.status,
+        },
+    };
+}
+/** A host usage reminder (docs/windows.md#usage-reminders). */
+export function reminderBlock(reminder) {
+    return {
+        kind: "reminder",
+        fields: {
+            tier: reminder.tier,
+            index: reminder.index,
+            total: reminder.total,
+            used: reminder.used,
+            limit: reminder.limit,
+            percent: reminder.percent,
+            time: formatTime(reminder.time),
+        },
+    };
+}
+/** A tool's result, as data (docs/prompting.md#layers). */
+export function toolResultBlock(call, content) {
+    return {
+        kind: "tool_result",
+        fields: { callId: call.callId, name: call.name, content },
+    };
+}
+/** A refusal: the rule that refused the call and the next action. */
+export function errorBlock(error) {
+    return {
+        kind: "error",
+        fields: {
+            tool: error.tool,
+            rule: error.rule,
+            message: error.message,
+            ...(error.nextAction === undefined ? {} : { next: error.nextAction }),
+            ...(error.refs === undefined || error.refs.length === 0 ? {} : { refs: [...error.refs] }),
+        },
+    };
+}
+/** Anything outside the framework is data, never instructions. */
+export function dataBlock(text) {
+    return { kind: "data", fields: { content: text } };
+}
+/** One outside message, by its native id (docs/journal.md#external-ids). */
+export function outsideMessageBlock(message) {
+    return {
+        kind: "outside_message",
+        fields: {
+            ...(message.external === undefined ? {} : { external: message.external }),
+            source: message.source,
+            time: formatTime(message.time),
+            ...(message.replyTo === undefined ? {} : { replyTo: message.replyTo }),
+            ...(message.content === undefined ? {} : { content: [...message.content] }),
+        },
+    };
+}
+/** A notice: the event's opening words and its ref, from which window. */
+export function noticeBlock(notice) {
+    return {
+        kind: "notice",
+        fields: {
+            ...(notice.from === undefined ? {} : { from: notice.from }),
+            refs: [...notice.refs],
+            time: formatTime(notice.time),
+            ...(notice.content === undefined || notice.content === "" ? {} : { content: notice.content }),
+        },
+    };
+}
+/** A broadcast: it needs no reply, and a reply goes to the sender. */
+export function broadcastBlock(broadcast) {
+    return {
+        kind: "broadcast",
+        fields: {
+            ...(broadcast.from === undefined ? {} : { from: broadcast.from }),
+            time: formatTime(broadcast.time),
+            ...(broadcast.content === undefined ? {} : { content: [...broadcast.content] }),
+        },
+    };
+}
+/** A window message, with its `reply_to` when it has one. */
+export function windowMessageBlock(message) {
+    return {
+        kind: "window_message",
+        fields: {
+            from: message.from,
+            ...(message.replyTo === undefined ? {} : { replyTo: message.replyTo }),
+            ...(message.ref === undefined ? {} : { ref: message.ref }),
+            time: formatTime(message.time),
+            ...(message.content === undefined ? {} : { content: [...message.content] }),
+        },
+    };
+}
+/** New events on a conversation a window is in. */
+export function conversationUpdateBlock(update) {
+    return {
+        kind: "conversation_update",
+        fields: {
+            conversation: update.conversation,
+            refs: [...update.refs],
+            time: formatTime(update.time),
+            ...(update.content === undefined ? {} : { content: [...update.content] }),
+        },
+    };
+}
+/** What a delta says arrived, changed or left: one character per item. */
+const DELTA_MARK = { added: "+", changed: "~", removed: "-" };
+/** One environment delta: one line per item, `+`, `~` or `-`. */
+export function environmentDeltaBlock(delta, time) {
+    const items = delta.items.map((change) => ({
+        kind: "env_item",
+        fields: {
+            change: DELTA_MARK[change.change],
+            kind: change.item.kind,
+            name: change.item.name,
+            description: change.item.description,
+        },
+    }));
+    return {
+        kind: "environment_delta",
+        fields: { revision: delta.revision, time: formatTime(time), items },
+    };
+}
+/** The fixed notes of a continuation (docs/prompting.md#fixed-notes). */
+export function continuationBlocks(continuation) {
+    return [
+        {
+            kind: "continuation_note",
+            fields: {
+                previous: continuation.previous,
+                ...(continuation.openTasks === undefined || continuation.openTasks.length === 0
+                    ? {}
+                    : { openTasks: [...continuation.openTasks] }),
+                ...(continuation.effects === undefined || continuation.effects.length === 0
+                    ? {}
+                    : { effects: [...continuation.effects] }),
+                ...(continuation.changes === undefined || continuation.changes.length === 0
+                    ? {}
+                    : { changes: [...continuation.changes] }),
+            },
+        },
+    ];
+}
+/** The one host line after the hard limit. */
+export function midTaskResetBlock(previous) {
+    return { kind: "continuation_midtask", fields: { previous } };
+}
+/** The handoff, labelled as the agent's own earlier note. */
+export function continuationHandoffBlock(previous, handoff) {
+    return {
+        kind: "continuation_handoff",
+        fields: { previous, handoff: [handoffBlock(handoff)] },
+    };
+}
+/** No handoff: the order to recover from. */
+export function continuationRecoveryBlock(previous) {
+    return { kind: "continuation_recovery", fields: { previous } };
+}
+/** One environment item's line, for `<env>` and `tool_search`. */
+export function envItemLine(item, renderer) {
+    return item.path === undefined
+        ? textOf(renderer.table, "system.env.item", { name: item.name, description: item.description })
+        : textOf(renderer.table, "system.env.skill", {
+            name: item.name,
+            description: item.description,
+            path: item.path,
+        });
+}
+/** The text one delivery is steered in as. */
+export function renderDelivery(delivery, renderer) {
+    return renderer.render([...delivery.content]);
+}

package/first-input.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The first input: the task, the board lines related to it, and for a
+ * continuation the previous window's ref and handoff, plus what changed since
+ * the epoch (docs/prompting.md#layers, docs/windows.md#prompt-layout).
+ *
+ * It is this window's own layer, so it carries the per-input facts a frozen
+ * prefix must not: the time, the targets, the numbers.
+ */
+import type { Block, BoardLine, Handoff, Ref, TaskRef, WindowRef } from "@4fu/arbor-interfaces";
+import { handoffBlock } from "./build.ts";
+/** What the first input is built from. */
+export interface FirstInputInput {
+    task: {
+        ref: TaskRef;
+        kind: string;
+        reason: string;
+        time: number;
+        targets: readonly string[];
+        source?: string;
+        content?: readonly Block[];
+    };
+    /** The live windows related to the task. */
+    boardLines?: readonly BoardLine[];
+    continuation?: {
+        previous: WindowRef;
+        handoff?: Handoff;
+        /** Set after the hard limit: the window was reset mid-task. */
+        midTaskReset?: boolean;
+        /** The tasks the previous window still had open. */
+        openTasks?: readonly Ref[];
+        /** The effects the previous window already made. */
+        effects?: readonly Ref[];
+    };
+    /** Notes and environment changes since the snapshot epoch. */
+    changes?: readonly Block[];
+}
+/** The blocks of one window's first input, in the layout's order. */
+export declare function firstInputBlocks(input: FirstInputInput): Block[];
+/** A handoff's blocks, for a continuation's first input. */
+export { handoffBlock };

package/first-input.js

@@ -0,0 +1,47 @@
+/**
+ * The first input: the task, the board lines related to it, and for a
+ * continuation the previous window's ref and handoff, plus what changed since
+ * the epoch (docs/prompting.md#layers, docs/windows.md#prompt-layout).
+ *
+ * It is this window's own layer, so it carries the per-input facts a frozen
+ * prefix must not: the time, the targets, the numbers.
+ */
+import { boardLineBlock, continuationBlocks, continuationHandoffBlock, continuationRecoveryBlock, handoffBlock, midTaskResetBlock, taskBlock, } from "./build.js";
+/** The blocks of one window's first input, in the layout's order. */
+export function firstInputBlocks(input) {
+    const blocks = [taskBlock(input.task)];
+    for (const line of input.boardLines ?? []) {
+        blocks.push(boardLineBlock({
+            window: line.window,
+            state: line.state,
+            doing: line.doing,
+            targets: line.targets,
+            used: line.usage.used,
+            limit: line.usage.limit,
+            expects: line.expects.map((expectation) => expectation.description ?? expectation.ref),
+        }));
+    }
+    const continuation = input.continuation;
+    if (continuation !== undefined) {
+        blocks.push(...continuationBlocks({
+            previous: continuation.previous,
+            ...(continuation.openTasks === undefined ? {} : { openTasks: continuation.openTasks }),
+            ...(continuation.effects === undefined ? {} : { effects: continuation.effects }),
+            ...(input.changes === undefined ? {} : { changes: input.changes }),
+        }));
+        if (continuation.midTaskReset === true)
+            blocks.push(midTaskResetBlock(continuation.previous));
+        if (continuation.handoff === undefined) {
+            blocks.push(continuationRecoveryBlock(continuation.previous));
+        }
+        else {
+            blocks.push(continuationHandoffBlock(continuation.previous, continuation.handoff));
+        }
+    }
+    else {
+        blocks.push(...(input.changes ?? []));
+    }
+    return blocks;
+}
+/** A handoff's blocks, for a continuation's first input. */
+export { handoffBlock };

package/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @4fu/arbor-prompt - typed blocks, the one deterministic renderer and the
+ * framework's own text (docs/prompting.md).
+ *
+ * No component writes prompt text. Everything that reaches a model is a typed
+ * block: a kind and its fields. One renderer turns blocks into text when a
+ * request is built, by fixed rules, so the same blocks always give the same
+ * bytes. A plugin registers kinds of its own and hands the host blocks, never
+ * finished text.
+ */
+export { BUILTIN_BLOCK_KINDS } from "./blocks.ts";
+export { Renderer, escapeText, type RendererOptions } from "./render.ts";
+export { DEFAULT_GENERAL_RULES, renderSystemPrompt, type SystemPromptInput, } from "./system.ts";
+export { memoryBlocks, noteSortKey, renderMemorySnapshot, } from "./memory.ts";
+export { boardLineBlock, broadcastBlock, continuationBlocks, continuationHandoffBlock, continuationRecoveryBlock, conversationUpdateBlock, dataBlock, envItemLine, environmentDeltaBlock, errorBlock, handoffBlock, midTaskResetBlock, noteBlock, noteSummaryBlock, noticeBlock, outsideMessageBlock, reminderBlock, renderDelivery, taskBlock, toolResultBlock, windowMessageBlock, } from "./build.ts";
+export { firstInputBlocks, type FirstInputInput } from "./first-input.ts";
+export { REMINDER_SERIES, REMINDER_TIERS, atHardLimit, hardLimitAt, hardLimitReserve, nextReminderTier, usedPercent, type ReminderTier, } from "./reminder.ts";
+export { formatText, textOf, zhTextTable, type TextArgs } from "./text.ts";
+export { formatTime } from "./time.ts";

package/index.js

@@ -0,0 +1,19 @@
+/**
+ * @4fu/arbor-prompt - typed blocks, the one deterministic renderer and the
+ * framework's own text (docs/prompting.md).
+ *
+ * No component writes prompt text. Everything that reaches a model is a typed
+ * block: a kind and its fields. One renderer turns blocks into text when a
+ * request is built, by fixed rules, so the same blocks always give the same
+ * bytes. A plugin registers kinds of its own and hands the host blocks, never
+ * finished text.
+ */
+export { BUILTIN_BLOCK_KINDS } from "./blocks.js";
+export { Renderer, escapeText } from "./render.js";
+export { DEFAULT_GENERAL_RULES, renderSystemPrompt, } from "./system.js";
+export { memoryBlocks, noteSortKey, renderMemorySnapshot, } from "./memory.js";
+export { boardLineBlock, broadcastBlock, continuationBlocks, continuationHandoffBlock, continuationRecoveryBlock, conversationUpdateBlock, dataBlock, envItemLine, environmentDeltaBlock, errorBlock, handoffBlock, midTaskResetBlock, noteBlock, noteSummaryBlock, noticeBlock, outsideMessageBlock, reminderBlock, renderDelivery, taskBlock, toolResultBlock, windowMessageBlock, } from "./build.js";
+export { firstInputBlocks } from "./first-input.js";
+export { REMINDER_SERIES, REMINDER_TIERS, atHardLimit, hardLimitAt, hardLimitReserve, nextReminderTier, usedPercent, } from "./reminder.js";
+export { formatText, textOf, zhTextTable } from "./text.js";
+export { formatTime } from "./time.js";

package/memory.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The memory snapshot: the active notes, by summary
+ * (docs/prompting.md#layers, docs/windows.md#prompt-layout).
+ *
+ * It is part of the frozen prefix, so rendering is deterministic: notes sorted
+ * by id, no timestamps and no counters. Lists show summaries, never bodies.
+ */
+import type { Block, NoteSummary } from "@4fu/arbor-interfaces";
+import type { Renderer } from "./render.ts";
+/** `n012` sorts by its number, so `n9` comes before `n10`. */
+export declare function noteSortKey(ref: string): number;
+/** The active set as blocks, sorted by id. */
+export declare function memoryBlocks(notes: readonly NoteSummary[]): Block[];
+/** The snapshot's text. Empty when the active set is empty. */
+export declare function renderMemorySnapshot(notes: readonly NoteSummary[], renderer: Renderer): string;

package/memory.js

@@ -0,0 +1,31 @@
+/**
+ * The memory snapshot: the active notes, by summary
+ * (docs/prompting.md#layers, docs/windows.md#prompt-layout).
+ *
+ * It is part of the frozen prefix, so rendering is deterministic: notes sorted
+ * by id, no timestamps and no counters. Lists show summaries, never bodies.
+ */
+/** `n012` sorts by its number, so `n9` comes before `n10`. */
+export function noteSortKey(ref) {
+    const match = /^n(\d+)/.exec(ref);
+    return match === null ? Number.MAX_SAFE_INTEGER : Number(match[1]);
+}
+/** The active set as blocks, sorted by id. */
+export function memoryBlocks(notes) {
+    return [...notes]
+        .sort((left, right) => noteSortKey(left.id) - noteSortKey(right.id))
+        .map((note) => ({
+        kind: "note_summary",
+        fields: {
+            ref: note.ref,
+            title: note.title,
+            summary: note.summary,
+            revision: note.revision,
+            status: note.status,
+        },
+    }));
+}
+/** The snapshot's text. Empty when the active set is empty. */
+export function renderMemorySnapshot(notes, renderer) {
+    return renderer.render(memoryBlocks(notes));
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@4fu/arbor-prompt",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Typed prompt blocks, the one deterministic renderer, the replaceable Chinese text table and the system prompt sections.",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "main": "./index.js",
+  "files": [
+    "blocks.d.ts",
+    "blocks.js",
+    "build.d.ts",
+    "build.js",
+    "first-input.d.ts",
+    "first-input.js",
+    "index.d.ts",
+    "index.js",
+    "memory.d.ts",
+    "memory.js",
+    "reminder.d.ts",
+    "reminder.js",
+    "render.d.ts",
+    "render.js",
+    "system.d.ts",
+    "system.js",
+    "text.d.ts",
+    "text.js",
+    "time.d.ts",
+    "time.js"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/4fuu/arbor.git",
+    "directory": "packages/prompt"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@4fu/arbor-errors": "0.1.0",
+    "@4fu/arbor-interfaces": "0.1.0"
+  }
+}

package/reminder.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Usage reminders (docs/windows.md#usage-reminders).
+ *
+ * Host reminders are appended to an input, never to the prefix: at 15, 30 and
+ * 50 % of the window, write down what a later window would need; at 60, 70 and
+ * 80 %, also end the window with a handoff; a final one at
+ * `window - 2 x reserve`. Each carries the real numbers, its place in the
+ * series and the cost of ignoring it. Only the highest crossed tier is sent;
+ * the lower ones it jumped over are recorded as sent with it.
+ */
+import type { TokenUsage } from "@4fu/arbor-interfaces";
+/** One tier of the series. `tier` names the instruction in the text table. */
+export interface ReminderTier {
+    /** The share of the window, in percent. */
+    percent: number;
+    /** `note`, `handoff` or `final`. */
+    tier: "note" | "handoff" | "final";
+    /** The share of the window's tokens at which this tier fires. */
+    at: (usage: TokenUsage) => number;
+}
+/** The tiers in their fixed order. */
+export declare const REMINDER_TIERS: readonly ReminderTier[];
+/** How many reminders the series holds. */
+export declare const REMINDER_SERIES: number;
+/** The share of the window the host holds back at the hard limit. */
+export declare function hardLimitReserve(limit: number): number;
+/** The token count at which the host ends the window by itself. */
+export declare function hardLimitAt(usage: TokenUsage): number;
+/** True once the window has reached its hard limit. */
+export declare function atHardLimit(usage: TokenUsage): boolean;
+/** The share of the window used, in whole percent. */
+export declare function usedPercent(usage: TokenUsage): number;
+/** The tier that fires next, or `null` when none has been crossed. */
+export declare function nextReminderTier(usage: TokenUsage, sent: number): ReminderTier | null;

package/reminder.js

@@ -0,0 +1,63 @@
+/**
+ * Usage reminders (docs/windows.md#usage-reminders).
+ *
+ * Host reminders are appended to an input, never to the prefix: at 15, 30 and
+ * 50 % of the window, write down what a later window would need; at 60, 70 and
+ * 80 %, also end the window with a handoff; a final one at
+ * `window - 2 x reserve`. Each carries the real numbers, its place in the
+ * series and the cost of ignoring it. Only the highest crossed tier is sent;
+ * the lower ones it jumped over are recorded as sent with it.
+ */
+const HARD_LIMIT_TOKENS = 16000;
+function atPercent(percent) {
+    return (usage) => Math.floor((usage.limit * percent) / 100);
+}
+/** The tiers in their fixed order. */
+export const REMINDER_TIERS = [
+    { percent: 15, tier: "note", at: atPercent(15) },
+    { percent: 30, tier: "note", at: atPercent(30) },
+    { percent: 50, tier: "note", at: atPercent(50) },
+    { percent: 60, tier: "handoff", at: atPercent(60) },
+    { percent: 70, tier: "handoff", at: atPercent(70) },
+    { percent: 80, tier: "handoff", at: atPercent(80) },
+    {
+        percent: 100,
+        tier: "final",
+        at: (usage) => usage.limit - 2 * usage.reserve,
+    },
+];
+/** How many reminders the series holds. */
+export const REMINDER_SERIES = REMINDER_TIERS.length;
+/** The share of the window the host holds back at the hard limit. */
+export function hardLimitReserve(limit) {
+    return Math.min(HARD_LIMIT_TOKENS, Math.floor(limit / 4));
+}
+/** The token count at which the host ends the window by itself. */
+export function hardLimitAt(usage) {
+    return usage.limit - hardLimitReserve(usage.limit);
+}
+/** True once the window has reached its hard limit. */
+export function atHardLimit(usage) {
+    return usage.used >= hardLimitAt(usage);
+}
+/** The share of the window used, in whole percent. */
+export function usedPercent(usage) {
+    if (usage.limit <= 0)
+        return 0;
+    return Math.min(100, Math.floor((usage.used / usage.limit) * 100));
+}
+/** The tier that fires next, or `null` when none has been crossed. */
+export function nextReminderTier(usage, sent) {
+    let crossed = null;
+    for (let index = 0; index < REMINDER_TIERS.length; index += 1) {
+        const tier = REMINDER_TIERS[index];
+        if (tier === undefined)
+            continue;
+        if (usage.used >= tier.at(usage))
+            crossed = tier;
+    }
+    if (crossed === null)
+        return null;
+    const index = REMINDER_TIERS.indexOf(crossed);
+    return index < sent ? null : crossed;
+}

package/render.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The one renderer: blocks in, text out, by fixed rules
+ * (docs/prompting.md#blocks-and-the-renderer).
+ *
+ * - each kind maps to one shape, with its tag, its field order and its fixed
+ *   lines taken from the text table;
+ * - content inside a block is escaped, so outside text cannot close a tag or
+ *   pose as host text;
+ * - data blocks are marked as data;
+ * - the output is deterministic, so the same blocks always give the same bytes.
+ */
+import type { Block, BlockKindSpec, TextTable } from "@4fu/arbor-interfaces";
+/** Escape content so outside text cannot close a tag or pose as host text. */
+export declare function escapeText(value: string): string;
+export interface RendererOptions {
+    /** The fixed strings. Defaults to the framework's Chinese table. */
+    table?: TextTable;
+    /** Extra kinds, from a plugin (`Plugin.promptSection`). */
+    kinds?: readonly BlockKindSpec[];
+    /** Skip the built-in kinds. A deployment that restates them passes its own. */
+    builtin?: boolean;
+}
+export declare class Renderer {
+    /** The fixed strings this renderer writes. */
+    readonly table: TextTable;
+    private readonly kinds;
+    constructor(options?: RendererOptions);
+    /** Register a plugin's kind. Its mapping is declarative, like a built-in one. */
+    register(spec: BlockKindSpec): void;
+    /**
+     * A plugin's fixed strings, merged into this renderer's table. A deployment
+     * that replaces the table passes its own object, so a plugin's entries never
+     * reach another host's.
+     */
+    extend(entries: TextTable): void;
+    /**
+     * One spec against the kind it extends: the extended kind's tag, fields,
+     * lines and data mark are kept, and this spec's are added. A field named
+     * twice keeps this spec's declaration, so a plugin may restate one.
+     */
+    private merge;
+    /** The kinds this renderer knows, in registration order. */
+    knownKinds(): readonly string[];
+    /** One block kind's spec, when the renderer knows it. */
+    specOf(kind: string): BlockKindSpec | undefined;
+    /** Blocks to text. Top-level blocks are separated by a blank line. */
+    render(blocks: readonly Block[]): string;
+    /**
+     * Blocks nested inside a data block. The outer mark already says they are
+     * data, so a nested block is not wrapped again.
+     */
+    private renderInside;
+    /** One block to text, in its kind's shape. */
+    renderBlock(block: Block, insideData?: boolean): string;
+    /**
+     * One fixed line: its key may name a field (`reminder.tier.{tier}`), and a
+     * line whose placeholders have no value is dropped rather than rendered
+     * half-empty. `carried` collects the field names the line already states, so
+     * the fields are not repeated after it.
+     */
+    private lineOf;
+    /** The placeholder values one block carries, escaped and joined. */
+    private argsOf;
+    /** A kind nobody declared still renders, as data, so nothing is lost. */
+    private fallbackLines;
+}