@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/src/cli/render/task.js

@@ -0,0 +1,105 @@
+function row(value) {
+    const disposition = "disposition" in value ? value.disposition : value.state;
+    return `${value.id} - P${value.priority} - ${disposition} - ${value.title}`;
+}
+function changes(values) {
+    return values.map((change) => change.documentDiff).filter((diff) => diff.length > 0).join("\n");
+}
+function failure(result) {
+    return result.kind === "retry" ? `retry ${JSON.stringify(result.reason)}` : `refused ${JSON.stringify(result.refusal)}`;
+}
+function renderRows(result) {
+    if (result.kind !== "accepted")
+        return failure(result);
+    return result.value.map((item) => {
+        const blockers = "blockers" in item ? item.blockers.map((blocker) => blocker.id).join(", ") : undefined;
+        return `${row(item)}${blockers === undefined ? "" : ` <- ${blockers}`}`;
+    }).join("\n");
+}
+function renderShow(result) {
+    if ("kind" in result)
+        return result.kind === "accepted" ? row(result.value) : failure(result);
+    const task = result.task, lines = [
+        row(task), `namespace: ${task.namespace.join("/") || "root"}`,
+        `createdAt: ${task.createdAt}`, `updatedAt: ${task.updatedAt}`, `note: ${task.note}`,
+    ];
+    for (const [label, values] of [
+        ["needs", task.needs], ["blockers", result.blockers.map((item) => item.id)], ["blocks", result.blocks.map((item) => item.id)],
+        ["children", result.children.map((item) => item.id)], ["supersedes", task.supersedes],
+        ["superseded by", result.supersededBy.map((item) => item.id)], ["related", result.related.map((item) => item.id)],
+    ])
+        if (values.length > 0)
+            lines.push(`${label}: ${values.join(", ")}`);
+    if (task.parent !== null)
+        lines.push(`parent: ${task.parent}`);
+    if (task.body.length > 0)
+        lines.push("", task.body);
+    return lines.join("\n");
+}
+function treeLines(node, depth = 0) {
+    const marker = node.cycle ? "cycle" : node.reference ? "reference" : node.task.state;
+    const line = `${"  ".repeat(depth)}${node.task.id} - ${node.task.priority === null ? "P?" : `P${node.task.priority}`} - ${marker}${node.task.title === null ? "" : ` - ${node.task.title}`}`;
+    return [line, ...node.needs.flatMap((child) => treeLines(child, depth + 1))];
+}
+function doctorIssue(issue) {
+    if (issue.kind === "missing-target")
+        return `${issue.taskId}: ${issue.relation} target missing: ${issue.target}`;
+    if (issue.kind === "self-relation")
+        return `${issue.taskId}: self ${issue.relation}`;
+    return `${issue.relation} cycle: ${issue.tasks.join(" -> ")}`;
+}
+export function renderTaskText(command, result) {
+    if (command.action === "show")
+        return renderShow(result);
+    if (command.action === "ls" || command.action === "ready" || command.action === "blocked")
+        return renderRows(result);
+    if (command.action === "tree") {
+        const tree = result;
+        return tree.kind === "accepted" ? treeLines(tree.value).join("\n") : failure(tree);
+    }
+    if (command.action === "doctor") {
+        const report = result;
+        return report.issues.length === 0 ? "healthy" : report.issues.map(doctorIssue).join("\n");
+    }
+    if (command.action === "namespace") {
+        const namespace = result;
+        return namespace.kind === "accepted" ? namespace.value.join("/") || "root" : failure(namespace);
+    }
+    if (command.action === "compose") {
+        const composition = result;
+        return composition.kind === "accepted" ? changes(composition.documentChanges) : composition.kind === "incomplete" ? "" : failure(composition);
+    }
+    if (command.action === "hold" || command.action === "done" || command.action === "drop") {
+        const batch = result;
+        return batch.items.map((item) => item.outcome.kind === "accepted" ? `accepted ${item.id}` : `${item.id}: ${failure(item.outcome)}`).join("\n");
+    }
+    const mutation = result;
+    if (mutation.kind !== "accepted")
+        return failure(mutation);
+    if (command.action === "update") {
+        const value = mutation.value;
+        return [row(value.task), value.documentDiff].filter((line) => line.length > 0).join("\n");
+    }
+    return row(mutation.value);
+}
+export function renderTaskIncompleteDiagnostic(result) {
+    if (result.kind !== "incomplete")
+        return "";
+    return [`incomplete ${JSON.stringify(result.stopped)}`, changes(result.documentChanges)].filter((line) => line.length > 0).join("\n");
+}
+export function taskExitCode(result) {
+    if (typeof result === "object" && result !== null && "issues" in result)
+        return result.issues.length === 0 ? 0 : 1;
+    if (typeof result === "object" && result !== null && "items" in result) {
+        const kinds = result.items.map((item) => item.outcome.kind);
+        return kinds.includes("retry") ? 2 : kinds.includes("refused") ? 1 : 0;
+    }
+    if (typeof result === "object" && result !== null && "kind" in result) {
+        const outcome = result;
+        if (outcome.kind === "retry")
+            return 2;
+        if (outcome.kind === "refused" || outcome.kind === "incomplete")
+            return 1;
+    }
+    return 0;
+}

package/build/src/cli/render/terminal.d.ts

@@ -0,0 +1,10 @@
+export type TextRenderContext = Readonly<{
+    columns: number;
+    color: boolean;
+}>;
+export declare function displayColumns(value: string): number;
+export declare function safeText(value: string): string;
+export declare function renderFacts(primary: string, facts: readonly string[], columns: number): readonly string[];
+export declare function renderTextBlock(value: string, indent: string, columns: number): readonly string[];
+export declare function renderVoiceRuler(left: string, right: string, columns: number): string;
+export declare function tone(value: string, kind: "dim" | "alert", color: boolean): string;

package/build/src/cli/render/terminal.js

@@ -0,0 +1,76 @@
+const WIDE_RANGES = [
+    [0x1100, 0x115f], [0x2329, 0x232a], [0x2e80, 0xa4cf], [0xac00, 0xd7a3],
+    [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60],
+    [0xffe0, 0xffe6], [0x1f300, 0x1faff], [0x20000, 0x3fffd],
+];
+function characterColumns(character) {
+    const point = character.codePointAt(0);
+    if (point === undefined || point === 0 || /\p{Mark}/u.test(character) || point === 0xfe0f)
+        return 0;
+    if (point < 0x20 || (point >= 0x7f && point < 0xa0))
+        return 0;
+    if (point === 0x303f)
+        return 1;
+    return WIDE_RANGES.some(([first, last]) => point >= first && point <= last) ? 2 : 1;
+}
+export function displayColumns(value) {
+    let columns = 0;
+    for (const character of value)
+        columns += characterColumns(character);
+    return columns;
+}
+export function safeText(value) {
+    return value.replaceAll(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => /\s/u.test(character) ? " " : "�");
+}
+export function renderFacts(primary, facts, columns) {
+    const head = safeText(primary);
+    const clean = facts.map(safeText);
+    if (clean.length === 0)
+        return [head];
+    const inline = `${head}  ${clean.join(" · ")}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    const lines = [head];
+    let current = "  ";
+    for (const fact of clean) {
+        const candidate = current === "  " ? `${current}${fact}` : `${current} · ${fact}`;
+        if (current !== "  " && displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `  ${fact}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+export function renderTextBlock(value, indent, columns) {
+    const words = safeText(value).trim().split(/\s+/u).filter((word) => word.length > 0);
+    if (words.length === 0)
+        return [indent];
+    const lines = [];
+    let current = indent;
+    for (const word of words) {
+        const candidate = current === indent ? `${indent}${word}` : `${current} ${word}`;
+        if (current !== indent && displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `${indent}${word}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+export function renderVoiceRuler(left, right, columns) {
+    const width = Math.max(20, Math.min(80, columns));
+    const occupied = displayColumns(left) + displayColumns(right) + 2;
+    if (occupied >= width)
+        return `${left}\n${"─".repeat(Math.max(1, width - displayColumns(right) - 1))} ${right}`;
+    return `${left} ${"─".repeat(width - occupied)} ${right}`;
+}
+export function tone(value, kind, color) {
+    if (!color)
+        return value;
+    return kind === "dim" ? `\u001b[2m${value}\u001b[0m` : `\u001b[31m${value}\u001b[0m`;
+}

package/build/src/cli/render/text.d.ts

@@ -0,0 +1,3 @@
+import type { InvocationResult } from "../result.js";
+import type { TextRenderContext } from "./terminal.js";
+export declare function renderText(result: InvocationResult, context?: TextRenderContext): string;

package/build/src/cli/render/text.js

@@ -0,0 +1,15 @@
+import { renderObservation } from "./board.js";
+import { renderAccepted, renderRetry } from "./contract.js";
+import { renderKanshiText } from "./kanshi.js";
+import { renderRefusal } from "./refusal.js";
+export function renderText(result, context) {
+    if (result.kind === "status")
+        return renderKanshiText(result.report, context, result.selection);
+    if (result.kind === "accepted")
+        return renderAccepted(result);
+    if (result.kind === "refused")
+        return renderRefusal(result);
+    if (result.kind === "retry")
+        return renderRetry(result);
+    return renderObservation(result);
+}

package/build/src/cli/result.d.ts

@@ -0,0 +1,55 @@
+import type { AuditReport, ChangeId, ContractId, Fact, PlacementStop, ReconcileReport, RegionOverlap, SettlementReport, SnapshotId, VerificationStop } from "../index.js";
+import type { KanshiReport } from "../kanshi/index.js";
+export type Effect = ReconcileReport["effects"][number];
+export type AcceptedFact = Readonly<{
+    contract: ContractId;
+    entry: string;
+    kind: Fact["kind"];
+}>;
+export type Lag = ReconcileReport["lag"][number];
+export type DiffUnavailable = Readonly<{
+    reason: "git-unavailable";
+    snapshotId: SnapshotId;
+    changeId: ChangeId;
+}>;
+export type AcceptedResult = Readonly<{
+    kind: "accepted";
+    verb: string;
+    contract: ContractId;
+    head: string | null;
+    facts: readonly AcceptedFact[];
+    effects: readonly Effect[];
+    settlement: SettlementReport;
+    target?: string | null;
+    verification?: VerificationStop;
+    placement?: PlacementStop;
+    leak?: NonNullable<AuditReport["leak"]>;
+    overlaps?: readonly RegionOverlap[];
+    overlapFailure?: string;
+    report?: AuditReport;
+    diff?: string | DiffUnavailable;
+    lag?: readonly Lag[];
+}>;
+export type RefusedResult = Readonly<{
+    kind: "refused";
+    verb: string;
+    contract?: ContractId;
+    refusal: unknown;
+}>;
+export type RetryResult = Readonly<{
+    kind: "retry";
+    verb: string;
+    contract?: ContractId;
+    detail: unknown;
+}>;
+export type ObservationResult = Readonly<{
+    kind: "observation";
+    command: string;
+    [key: string]: unknown;
+}>;
+export type StatusResult = Readonly<{
+    kind: "status";
+    report: KanshiReport;
+    selection: "world" | "contract";
+}>;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | StatusResult;

package/build/src/cli/selectors.d.ts

@@ -0,0 +1,9 @@
+import { Keiyaku, type ContractBoard, type ContractId, type Repo } from "../index.js";
+import type { KanshiReport } from "../kanshi/index.js";
+export type SelectedContract = Readonly<{
+    id: ContractId;
+    contract: Keiyaku;
+}>;
+export declare function contractFromInput(repo: Repo, value: string): SelectedContract;
+export declare function resolveContextualContract(board: ContractBoard, selector: string | undefined, scope: string): ContractId;
+export declare function resolveKanshiContract(report: KanshiReport, selector: string): string;

package/build/src/cli/selectors.js

@@ -0,0 +1,66 @@
+import { resolve } from "node:path";
+import { identitySegments } from "../identity/coordinates.js";
+import { Keiyaku } from "../index.js";
+import { CliUsageError } from "./parse.js";
+function selectorError(message) {
+    throw new CliUsageError(message);
+}
+function activeManagedCandidates(rows) {
+    return rows.flatMap((contract) => {
+        if (contract.disposition !== "active" || contract.workspace !== "worktree" || contract.worktreePath === null)
+            return [];
+        return [{ id: contract.id, worktreePath: contract.worktreePath }];
+    });
+}
+export function contractFromInput(repo, value) {
+    try {
+        const id = value;
+        return { id, contract: Keiyaku.of({ repo, id }) };
+    }
+    catch (error) {
+        selectorError(error instanceof Error ? error.message : String(error));
+    }
+}
+function resolveShortContract(rows, selector) {
+    if (selector.startsWith("@kei/"))
+        selectorError(`redundant short contract selector: ${selector}`);
+    const short = selector.slice(1);
+    const candidates = activeManagedCandidates(rows)
+        .filter((candidate) => candidate.id.slice("kei/".length) === short);
+    if (candidates.length === 0)
+        selectorError(`unknown contract selector: ${selector}`);
+    if (candidates.length !== 1)
+        selectorError(`ambiguous contract selector: ${selector}`);
+    return candidates[0].id;
+}
+function resolveOmittedContract(board, scope) {
+    const candidates = activeManagedCandidates(board.rows)
+        .filter((candidate) => resolve(scope) === resolve(candidate.worktreePath));
+    if (candidates.length === 0) {
+        selectorError("an explicit full or @ contract selector is required outside a managed worktree");
+    }
+    if (candidates.length !== 1)
+        selectorError("ambiguous managed worktree contract selector");
+    return candidates[0].id;
+}
+export function resolveContextualContract(board, selector, scope) {
+    if (selector === undefined)
+        return resolveOmittedContract(board, scope);
+    if (selector.startsWith("@"))
+        return resolveShortContract(board.rows, selector);
+    return selectorError(`contract selector must be kei/<contract-segment> or @<contract-segment>: ${selector}`);
+}
+export function resolveKanshiContract(report, selector) {
+    if (report.contracts.kind !== "present") {
+        return selectorError(`cannot select a contract while the Contract world is ${report.contracts.kind}`);
+    }
+    if (selector.startsWith("@"))
+        return resolveShortContract(report.contracts.value.rows, selector);
+    try {
+        identitySegments({ family: "kei", value: selector });
+    }
+    catch {
+        return selectorError(`contract selector must use kei/: ${selector}`);
+    }
+    return selector;
+}

package/build/src/cli/usage.d.ts

@@ -0,0 +1,6 @@
+export declare class CliUsageError extends Error {
+    readonly diagnostic: string;
+    readonly projection?: string | undefined;
+    constructor(diagnostic: string, projection?: string | undefined);
+}
+export declare function usageLine(usage: string): string;

package/build/src/cli/usage.js

@@ -0,0 +1,19 @@
+export class CliUsageError extends Error {
+    diagnostic;
+    projection;
+    constructor(diagnostic, projection) {
+        super(projection === undefined ? diagnostic : `${diagnostic}\n${projection}`);
+        this.diagnostic = diagnostic;
+        this.projection = projection;
+        this.name = "CliUsageError";
+    }
+}
+export function usageLine(usage) {
+    return usage.split("\n").map((line, index) => {
+        if (index === 0)
+            return `usage: keiyaku ${line}`;
+        return line.startsWith("task ")
+            ? `       keiyaku ${line}`
+            : `       ${line.trimStart()}`;
+    }).join("\n");
+}

package/build/src/context-root.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveContextRoot(input: Readonly<{
+    from: string;
+    marker: string;
+}>): string;

package/build/src/context-root.js

@@ -0,0 +1,15 @@
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { dirname, parse, resolve } from "node:path";
+export function resolveContextRoot(input) {
+    const origin = realpathSync(resolve(input.from));
+    for (let candidate = origin;; candidate = dirname(candidate)) {
+        const marker = resolve(candidate, input.marker);
+        if (existsSync(marker)) {
+            if (!statSync(marker).isDirectory())
+                throw new Error(`context marker is not a directory: ${marker}`);
+            return candidate;
+        }
+        if (candidate === parse(candidate).root)
+            return origin;
+    }
+}

package/build/src/coordination/durable-file.d.ts

@@ -0,0 +1 @@
+export declare function replaceFileDurably(path: string, bytes: string | Uint8Array): void;

package/build/src/coordination/durable-file.js

@@ -0,0 +1,36 @@
+import { randomBytes } from "node:crypto";
+import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export function replaceFileDurably(path, bytes) {
+    const parent = dirname(path);
+    for (;;) {
+        const temporary = resolve(parent, `.tmp-${randomBytes(8).toString("hex")}`);
+        let descriptor;
+        try {
+            descriptor = openSync(temporary, "wx", 0o600);
+            writeFileSync(descriptor, bytes);
+            fsyncSync(descriptor);
+            closeSync(descriptor);
+            descriptor = undefined;
+            renameSync(temporary, path);
+            const directory = openSync(parent, "r");
+            try {
+                fsyncSync(directory);
+            }
+            finally {
+                closeSync(directory);
+            }
+            return;
+        }
+        catch (error) {
+            if (descriptor !== undefined)
+                closeSync(descriptor);
+            try {
+                unlinkSync(temporary);
+            }
+            catch { /* renamed, absent, or best-effort cleanup */ }
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+}

package/build/src/coordination/sqlite-transaction-lock.d.ts

@@ -0,0 +1,14 @@
+export type SqliteTransactionLockMode = "immediate" | "exclusive";
+export declare class SqliteTransactionLockError extends Error {
+    readonly reason: "timeout" | "invalid" | "open-failed" | "release-failed";
+    constructor(message: string, reason: "timeout" | "invalid" | "open-failed" | "release-failed", options?: ErrorOptions);
+}
+export type HeldSqliteTransactionLock = Readonly<{
+    close(): void;
+}>;
+export declare function acquireSqliteTransactionLock(input: {
+    path: string;
+    mode: SqliteTransactionLockMode;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<HeldSqliteTransactionLock>;

package/build/src/coordination/sqlite-transaction-lock.js

@@ -0,0 +1,119 @@
+import { randomInt } from "node:crypto";
+import { lstatSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+const SQLITE_BUSY = 5;
+const INITIAL_RETRY_MS = 10;
+const MAX_RETRY_MS = 100;
+export class SqliteTransactionLockError extends Error {
+    reason;
+    constructor(message, reason, options) {
+        super(message, options);
+        this.reason = reason;
+        this.name = "SqliteTransactionLockError";
+    }
+}
+function detail(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isBusy(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const value = error;
+    const message = String(value.message ?? "").toLowerCase();
+    return value.errcode === SQLITE_BUSY || value.code === "ERR_SQLITE_BUSY"
+        || value.code === "ERR_SQLITE_LOCKED" || message.includes("database is locked")
+        || message.includes("database is busy");
+}
+function closeDatabase(database) {
+    let failure;
+    try {
+        database.exec("ROLLBACK");
+    }
+    catch (error) {
+        failure = error;
+    }
+    try {
+        database.close();
+    }
+    catch (error) {
+        failure ??= error;
+    }
+    return failure;
+}
+function openLock(path, mode) {
+    try {
+        const stat = lstatSync(path, { throwIfNoEntry: false });
+        if (stat && (!stat.isFile() || stat.isSymbolicLink())) {
+            throw new SqliteTransactionLockError(`SQLite lock is not a regular file: ${path}`, "invalid");
+        }
+        mkdirSync(dirname(path), { recursive: true });
+    }
+    catch (error) {
+        if (error instanceof SqliteTransactionLockError)
+            throw error;
+        throw new SqliteTransactionLockError(`cannot prepare SQLite lock: ${detail(error)}`, "open-failed", { cause: error });
+    }
+    let database;
+    try {
+        database = new DatabaseSync(path);
+        database.exec("PRAGMA busy_timeout=0");
+        database.exec("PRAGMA journal_mode=DELETE");
+        database.exec("CREATE TABLE IF NOT EXISTS lock_anchor (singleton INTEGER PRIMARY KEY CHECK (singleton = 1))");
+        database.exec(`BEGIN ${mode.toUpperCase()}`);
+        database.prepare("SELECT singleton FROM lock_anchor LIMIT 1").get();
+    }
+    catch (error) {
+        if (database)
+            closeDatabase(database);
+        if (isBusy(error))
+            throw error;
+        throw new SqliteTransactionLockError(`cannot acquire SQLite lock: ${detail(error)}`, "open-failed", { cause: error });
+    }
+    let closed = false;
+    return { close() {
+            if (closed)
+                return;
+            closed = true;
+            const failure = closeDatabase(database);
+            if (failure !== undefined) {
+                throw new SqliteTransactionLockError(`cannot release SQLite lock: ${detail(failure)}`, "release-failed", { cause: failure });
+            }
+        } };
+}
+function wait(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        const finish = () => { signal?.removeEventListener("abort", abort); resolve(); };
+        const timer = setTimeout(finish, milliseconds);
+        const abort = () => { clearTimeout(timer); signal?.removeEventListener("abort", abort); reject(signal?.reason); };
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
+    });
+}
+export async function acquireSqliteTransactionLock(input) {
+    if (input.path.length === 0 || (input.timeoutMs !== undefined
+        && (!Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 0))) {
+        throw new SqliteTransactionLockError("SQLite lock path and timeout must be valid", "invalid");
+    }
+    const started = performance.now();
+    let cap = INITIAL_RETRY_MS;
+    for (;;) {
+        input.signal?.throwIfAborted();
+        try {
+            return openLock(input.path, input.mode);
+        }
+        catch (error) {
+            if (!isBusy(error))
+                throw error;
+            const elapsed = performance.now() - started;
+            if (input.timeoutMs !== undefined && elapsed >= input.timeoutMs) {
+                throw new SqliteTransactionLockError(`SQLite lock timed out after ${input.timeoutMs}ms: ${input.path}`, "timeout", { cause: error });
+            }
+            const delay = randomInt(Math.ceil(cap / 2), cap + 1);
+            const remaining = input.timeoutMs === undefined ? delay : Math.min(delay, input.timeoutMs - elapsed);
+            await wait(Math.max(0, remaining), input.signal);
+            cap = Math.min(MAX_RETRY_MS, cap * 2);
+        }
+    }
+}

package/build/src/core/decide.d.ts

@@ -0,0 +1,45 @@
+import type { Offer } from "./facts/offer.js";
+import type { ContractsObservation } from "./facts/observation.js";
+import type { DocumentKey, EntryUlid } from "./facts/types.js";
+export type AttemptContext = Readonly<{
+    entryUlids: readonly EntryUlid[];
+}>;
+export type DecideInput<Input> = Readonly<{
+    input: Input;
+    attempt: AttemptContext;
+    observation: ContractsObservation;
+}>;
+/** The protocol's mechanical or declaration result supplied to a legal decision. */
+export type Preparation<Data, Refusal> = Readonly<{
+    kind: "prepared";
+    data: Data;
+    refusal?: never;
+} | {
+    kind: "refused";
+    refusal: Refusal;
+    data?: never;
+}>;
+/** A document-derived preparation whose stamp is unavailable only with contract absence. */
+export type StampedPreparation<Data, Refusal> = Readonly<{
+    kind: "unavailable";
+    document?: never;
+    data?: never;
+    refusal?: never;
+} | {
+    kind: "prepared";
+    document: DocumentKey;
+    data: Data;
+    refusal?: never;
+} | {
+    kind: "refused";
+    document: DocumentKey;
+    refusal: Refusal;
+    data?: never;
+}>;
+export type OfferDecision<Refusal> = Readonly<{
+    kind: "offer";
+    offer: Offer;
+}> | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}>;

package/build/src/core/facts/codec.d.ts

@@ -0,0 +1,3 @@
+import type { JournalEntry } from "./types.js";
+export declare function encodeEntry(entry: JournalEntry): string;
+export declare function decodeJournal(journal: string): JournalEntry[];