narraeon 0.5.7 → 0.6.1

package/dist/node/runtime/play/PlayDocumentTools.js

@@ -1,8 +1,8 @@
+import { createHash } from "node:crypto";
 import { HistoryQuery, historyInputs } from "../history/HistoryQuery.js";
 import { renderHistoryResult } from "../history/HistoryRendering.js";
 import { stateDirectoryHandle, parseStateDirectoryHandle, } from "../world/StateDirectoryHandles.js";
 import { renderDocumentWritePosition } from "../prompt/WorldMaintenanceReport.js";
-import { createHash } from "node:crypto";
 import { stringify } from "yaml";
 import { renderPlayerViewBindings } from "../world/PlayerViewBindings.js";
 import { PromptCompilationError, } from "../prompt/FileNativePromptCompiler.js";
@@ -56,66 +56,16 @@ export class FileNativePlayDocuments {
     get committedSnapshot() {
         return this.#committedSnapshot;
     }
-    bindBootstrap(bootstrap, previousAuthorization) {
-        const injected = bootstrapAuthorizations(bootstrap, this.#candidate.snapshot);
-        this.#reads = injected;
-        // Refreshing a prefix retains the native conversation. Its exact reads
-        // remain valid only on the identical state tree, including our own writes.
-        if (previousAuthorization?.stateFingerprint ===
-            fingerprintStateFiles(this.#candidate.files)) {
-            this.restoreAuthorizationCheckpoint(previousAuthorization);
-            for (const [ref, locators] of injected.documents) {
-                for (const locator of locators ?? [null])
-                    authorizeRead(this.#reads, this.#candidate.snapshot.id, ref, locator);
-            }
-        }
+    /**
+     * Read authorizations live only in memory (ADR-0044). A fresh binding starts
+     * from the bootstrap's own reads; writes are guarded at commit time by the
+     * previous-content hash of each changed file.
+     */
+    bindBootstrap(bootstrap) {
+        this.#reads = bootstrapAuthorizations(bootstrap, this.#candidate.snapshot);
         // Creation capabilities come from this prefix, not past directory slots.
         this.#declaredDirectories = declaredStateDirectories(bootstrap);
     }
-    authorizationCheckpoint() {
-        return {
-            schemaVersion: 1,
-            kind: "play_document_authorizations",
-            stateFingerprint: fingerprintStateFiles(this.#candidate.files),
-            documents: [...this.#reads.documents.entries()]
-                .sort(([left], [right]) => left.localeCompare(right))
-                .map(([shortRef, locators]) => ({
-                shortRef,
-                locators: locators === null
-                    ? null
-                    : locators
-                        .filter((locator, index, all) => all.findIndex((candidate) => sameLocator(candidate, locator)) === index)
-                        .map((locator) => structuredClone(locator)),
-            })),
-        };
-    }
-    restoreAuthorizationCheckpoint(checkpoint) {
-        if (!isPlayDocumentAuthorizationCheckpoint(checkpoint))
-            throw new TypeError("The play-document authorization checkpoint has an invalid format");
-        if (checkpoint.stateFingerprint !==
-            fingerprintStateFiles(this.#candidate.files))
-            throw new TypeError("The play-document authorization checkpoint does not match the current state");
-        const documents = new Map();
-        for (const { shortRef, locators } of checkpoint.documents) {
-            if (documentDescriptorByRef(this.#candidate.snapshot, shortRef) === null)
-                throw new TypeError(`The play-document authorization checkpoint refers to missing @${shortRef}`);
-            const restoredLocators = locators?.map((locator) => {
-                const selected = this.#candidate.snapshot.query({
-                    kind: "select_node",
-                    document: { shortRef },
-                    locator,
-                });
-                if (selected.kind !== "select_node" || !selected.ok)
-                    throw new TypeError(`The play-document authorization checkpoint refers to a missing node in @${shortRef}`);
-                return structuredClone(selected.node.locator);
-            });
-            documents.set(shortRef, restoredLocators ?? null);
-        }
-        this.#reads = {
-            snapshotId: this.#candidate.snapshot.id,
-            documents,
-        };
-    }
     execute(call, history, options = {}) {
         let historyQuery;
         const query = () => (historyQuery ??= new HistoryQuery(options.historyScope ?? "local-document-context", historyInputs(history)));
@@ -254,15 +204,6 @@ function authorizeToolRead(authorizations, snapshot, result) {
         return;
     authorizeRead(authorizations, snapshot.id, authorization.shortRef, authorization.locator);
 }
-function sameLocator(left, right) {
-    if (left === null || right === null)
-        return left === right;
-    const leftPath = "yaml" in left ? left.yaml : left.markdown;
-    const rightPath = "yaml" in right ? right.yaml : right.markdown;
-    return ("yaml" in left === "yaml" in right &&
-        leftPath.length === rightPath.length &&
-        leftPath.every((segment, index) => segment === rightPath[index]));
-}
 function parseYamlHandleSegment(segment) {
     return /^(?:0|[1-9][0-9]*)$/u.test(segment) ? Number(segment) : segment;
 }
@@ -914,64 +855,6 @@ export function fingerprintControl(files) {
         hash.update(path).update("\0").update(contents).update("\0");
     return `sha256:${hash.digest("hex")}`;
 }
-export function isPlayDocumentAuthorizationCheckpoint(value) {
-    if (!record(value) ||
-        !hasExactKeys(value, [
-            "schemaVersion",
-            "kind",
-            "stateFingerprint",
-            "documents",
-        ]) ||
-        value.schemaVersion !== 1 ||
-        value.kind !== "play_document_authorizations" ||
-        typeof value.stateFingerprint !== "string" ||
-        !/^sha256:[0-9a-f]{64}$/u.test(value.stateFingerprint) ||
-        !Array.isArray(value.documents) ||
-        value.documents.length > 100_000)
-        return false;
-    const refs = new Set();
-    for (const document of value.documents) {
-        if (!record(document) ||
-            !hasExactKeys(document, ["shortRef", "locators"]) ||
-            typeof document.shortRef !== "string" ||
-            !/^[a-z][a-z0-9-]*$/u.test(document.shortRef) ||
-            refs.has(document.shortRef) ||
-            (document.locators !== null &&
-                (!Array.isArray(document.locators) ||
-                    document.locators.length > 100_000 ||
-                    !document.locators.every(isPersistedAuthorizedLocator))))
-            return false;
-        refs.add(document.shortRef);
-    }
-    return true;
-}
-function fingerprintStateFiles(files) {
-    const hash = createHash("sha256");
-    for (const [path, contents] of Object.entries(files)
-        .filter(([path]) => path.startsWith("state/"))
-        .sort(([left], [right]) => left.localeCompare(right)))
-        hash.update(path).update("\0").update(contents).update("\0");
-    return `sha256:${hash.digest("hex")}`;
-}
-function isPersistedAuthorizedLocator(value) {
-    if (!record(value))
-        return false;
-    if (hasExactKeys(value, ["yaml"]))
-        return (Array.isArray(value.yaml) &&
-            value.yaml.length <= 64 &&
-            value.yaml.every((segment) => typeof segment === "string" ||
-                (Number.isSafeInteger(segment) && Number(segment) >= 0)));
-    if (hasExactKeys(value, ["markdown"]))
-        return (Array.isArray(value.markdown) &&
-            value.markdown.length <= 64 &&
-            value.markdown.every((segment) => typeof segment === "string"));
-    return false;
-}
-function hasExactKeys(value, expected) {
-    const keys = Object.keys(value);
-    return (keys.length === expected.length &&
-        expected.every((key) => Object.hasOwn(value, key)));
-}
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/node/runtime/play/PlayFollowupRequests.js

@@ -59,8 +59,8 @@ export async function runPlayFollowupRequests(input) {
             failure ??= outcome.failure;
     }
     const extension = failure === undefined
-        ? await input.artifacts.completeExtension(input.context.operationId, completed)
-        : await input.artifacts.failExtension(input.context.operationId, "recovery_required", failure, completed);
+        ? await input.artifacts.completeExtension(input.context.worldId, input.context.operationId, completed)
+        : await input.artifacts.failExtension(input.context.worldId, input.context.operationId, "recovery_required", failure, completed);
     return { outcomes, extension };
 }
 async function runOne(input, followup, prefix, requestSignal) {

package/dist/node/runtime/play/PlayTraceRetention.js

@@ -1,18 +1,18 @@
 import { captureNarrativeOrigin } from "../history/HistoryBackground.js";
-import { FileNativePlayDocuments, } from "./PlayDocumentTools.js";
+import { FileNativePlayDocuments } from "./PlayDocumentTools.js";
 import { currentPlayPrompt, playPromptRunsThroughEvents, } from "./PlayPromptRun.js";
 import { isPlayerRoundMarker, playerInputAppend } from "./PlayContinuity.js";
 import { PlayCallChainError } from "./PlayCallChainError.js";
 /**
- * Prepare the selected player's prefix at the existing pre-commit seam.
- * Endpoint reads, revision submission and publication belong to the operation.
+ * Split a context at a selected player message for an edit: the prefix before
+ * it is kept, and the replacement is appended once the world has rewound and
+ * committed it (PlayCallChain.revisePlayer).
  */
 export function preparePlayerRevisionTrace(source, eventIndex) {
     const prefix = structuredClone(source.events.slice(0, eventIndex));
     const transcript = transcriptThroughEvents(source.transcript, prefix);
     const player = source.events[eventIndex];
     return {
-        // This append precedes the operation's materialization check, as before.
         withReplacement(replacement) {
             const events = [
                 ...prefix,
@@ -46,7 +46,7 @@ export function preparePlayerRevisionTrace(source, eventIndex) {
         pagePrefixAtEndpoint(endpoint) {
             if (prefix.length === 0)
                 return null;
-            // Preserve the fresh path's post-commit prefix reconstruction seam.
+            // A fresh context keeps the page before the edit as a detached prefix.
             const prefixTranscript = transcriptThroughEvents(source.transcript, prefix);
             return assembleRetainedTrace(source, endpoint, {
                 events: prefix,
@@ -119,7 +119,6 @@ function assembleRetainedTrace(source, endpoint, selection) {
         completedTools: source.completedTools
             .filter(({ key }) => completedKeys === null || completedKeys.has(key))
             .map((item) => structuredClone(item)),
-        documentAuthorizationCheckpoints: authorizationCheckpointsThroughEvents(source, selection.events, documents.authorizationCheckpoint()),
         changedDocuments: changedDocumentsAtHead(source.changedDocuments, endpoint.baseline.state, endpoint.selected.state),
         nextMaterials: structuredClone(selection.materials),
         nextEventId: Math.max(0, ...selection.events.map(({ id }) => id)) + 1,
@@ -132,29 +131,16 @@ function assembleRetainedTrace(source, endpoint, selection) {
 export function restorePlayDocuments(files, context, events) {
     const documents = new FileNativePlayDocuments(files);
     try {
-        const checkpoint = documentAuthorizationThroughEvents(context, events);
+        // Read authorizations are memory-only: a restored prefix always starts from
+        // its bootstrap, and stale write authority is caught by the commit's hash.
         const runs = playPromptRunsThroughEvents(context, events);
-        if (checkpoint === undefined || runs.length > 0)
-            documents.bindBootstrap(currentPlayPrompt({ ...context, promptRuns: runs }).bootstrap);
-        if (checkpoint !== undefined)
-            documents.restoreAuthorizationCheckpoint(checkpoint.authorization);
+        documents.bindBootstrap(currentPlayPrompt({ ...context, promptRuns: runs }).bootstrap);
     }
     catch (error) {
         throw new PlayCallChainError(`Call-chain document authorization could not be restored: ${error instanceof Error ? error.message : "invalid checkpoint"}。`);
     }
     return documents;
 }
-function documentAuthorizationThroughEvents(context, events) {
-    const checkpoints = context.documentAuthorizationCheckpoints;
-    if (checkpoints === undefined || checkpoints.length === 0)
-        return undefined;
-    const selectedEventIds = new Set(events.map(({ id }) => id));
-    const selected = checkpoints.findLast(({ afterEventId }) => afterEventId === 0 || selectedEventIds.has(afterEventId));
-    // Legacy V1 records had no durable dynamic authorization. If the selected
-    // prefix predates their first lazily-written checkpoint, retain the exact
-    // old recovery behavior and rebuild only bootstrap authorization.
-    return selected === undefined ? undefined : structuredClone(selected);
-}
 export function independentContextCopy(source) {
     const context = structuredClone(source);
     context.continuityContextId ??= source.chainId;
@@ -162,20 +148,6 @@ export function independentContextCopy(source) {
     delete context.branchedBeforePlayer;
     return context;
 }
-function authorizationCheckpointsThroughEvents(context, events, fallback) {
-    const eventIds = new Set(events.map(({ id }) => id));
-    const selected = (context.documentAuthorizationCheckpoints ?? [])
-        .filter(({ afterEventId }) => afterEventId === 0 || eventIds.has(afterEventId))
-        .map((checkpoint) => structuredClone(checkpoint));
-    if (selected.length > 0)
-        return selected;
-    return [
-        {
-            afterEventId: Math.max(0, ...events.map(({ id }) => id)),
-            authorization: structuredClone(fallback),
-        },
-    ];
-}
 function transcriptThroughEvents(transcript, events) {
     const result = [];
     let cursor = 0;

package/dist/node/runtime/play/TabletopResolution.js

@@ -0,0 +1,372 @@
+import { createHmac } from "node:crypto";
+import { Ajv } from "ajv";
+import { arithmeticTotal, d100Outcome, d20Outcome, isResolutionReceipt, percentileCandidate, } from "../../protocol/resolution.js";
+export const resolutionToolNames = [
+    "d20_check",
+    "percentile_check",
+    "bag_check",
+    "roll_dice",
+    "calculate",
+];
+export function isResolutionTool(name) {
+    return resolutionToolNames.some((item) => item === name);
+}
+const checkToolByScheme = {
+    d20: "d20_check",
+    d100: "percentile_check",
+    bag: "bag_check",
+};
+/** The one check tool that embodies a tabletop scheme. Auxiliary tools never decide success. */
+export function resolutionCheckToolForScheme(scheme) {
+    return checkToolByScheme[scheme];
+}
+const integer = (minimum, maximum) => ({
+    type: "integer",
+    minimum,
+    maximum,
+});
+const number = { type: "number", minimum: -1_000_000, maximum: 1_000_000 };
+const goal = { type: "string", minLength: 1, maxLength: 1000, pattern: "\\S" };
+const object = (properties, required) => ({
+    type: "object",
+    additionalProperties: false,
+    properties,
+    required,
+});
+const resolutionSchemas = {
+    d20_check: object({
+        goal,
+        modifier: integer(-1_000_000, 1_000_000),
+        difficulty: integer(-1_000_000, 1_000_000),
+        mode: { enum: ["normal", "advantage", "disadvantage"] },
+    }, ["goal", "modifier", "difficulty"]),
+    percentile_check: object({
+        goal,
+        target: integer(0, 100),
+        bonusDice: integer(0, 2),
+        penaltyDice: integer(0, 2),
+    }, ["goal", "target"]),
+    bag_check: object({
+        goal,
+        value: number,
+        difficulty: number,
+        tokens: {
+            type: "array",
+            minItems: 1,
+            maxItems: 100,
+            items: object({
+                label: { type: "string", minLength: 1, maxLength: 80 },
+                count: integer(1, 100),
+                modifier: number,
+                outcome: { enum: ["critical_success", "critical_failure"] },
+            }, ["label", "count"]),
+        },
+    }, ["goal", "value", "difficulty"]),
+    roll_dice: object({ goal, count: integer(1, 100), sides: integer(2, 1000), modifier: number }, ["goal", "count", "sides"]),
+    calculate: object({
+        goal,
+        left: number,
+        right: number,
+        operation: { enum: ["add", "subtract", "multiply", "divide"] },
+    }, ["goal", "left", "right", "operation"]),
+};
+const descriptions = {
+    d20_check: [
+        "掷 d20 判定。原始 20 大成功、1 大失败；其余取值加 modifier >= difficulty 成功。优势两骰取高，劣势取低。先确定目标和数值，结果必须兑现。",
+        "Resolve a d20 check. Selected raw 20 critically succeeds, 1 critically fails; otherwise roll + modifier >= difficulty succeeds. Advantage keeps the higher of two dice, disadvantage the lower. Declare the goal and values before rolling; honour the result.",
+    ],
+    percentile_check: [
+        "百分骰判定。共享个位，奖励/惩罚额外十位骰相消后取较低/较高的完整结果，00 与个位0表示100。最终1大成功、100大失败，其余 <= target 成功。",
+        "Resolve a percentile check. Bonus/penalty tens dice cancel, share one units die, and select the lowest/highest complete result; 00 with units 0 means 100. Selected 1 critically succeeds, 100 critically fails; otherwise <= target succeeds.",
+    ],
+    bag_check: [
+        "从当前标记清单按数量抽一枚并放回。数值 value + 标记修正 >= difficulty 成功；特殊标记覆盖成败。省略 tokens 使用默认袋（+1、0×2、-1×2、-2、大成功、大失败）。自定义袋先从世界文档读取，原样提供；每种标记必须恰好有 modifier 或 outcome。",
+        "Draw one token by quantity, with replacement. value + token modifier >= difficulty succeeds; a special outcome overrides comparison. Omit tokens for the default bag (+1, 0 x2, -1 x2, -2, critical success, critical failure). Read a custom bag from world documents and supply it exactly; every token has exactly one modifier or outcome.",
+    ],
+    roll_dice: [
+        "辅助数值掷骰：count 枚 sides 面骰求和加 modifier。用于伤害、数量等，不重新裁决已确定的行动成败。",
+        "Roll auxiliary numeric dice: sum count dice of sides faces and add modifier. Use for damage or quantities, not to reverse a resolved action.",
+    ],
+    calculate: [
+        "对两个数执行加减乘除，不产生随机数，不修改世界。",
+        "Add, subtract, multiply or divide two numbers without randomness or world changes.",
+    ],
+};
+export function resolutionToolDefinition(name, locale) {
+    return {
+        name,
+        description: descriptions[name][locale === "zh-CN" ? 0 : 1],
+        inputSchema: structuredClone(resolutionSchemas[name]),
+    };
+}
+const ajv = new Ajv({ allErrors: true, strict: true });
+const validators = Object.fromEntries(resolutionToolNames.map((name) => [
+    name,
+    ajv.compile(resolutionSchemas[name]),
+]));
+const defaultBagTokens = [
+    { label: "+1", count: 1, modifier: 1 },
+    { label: "0", count: 2, modifier: 0 },
+    { label: "-1", count: 2, modifier: -1 },
+    { label: "-2", count: 1, modifier: -2 },
+    { label: "critical_success", count: 1, outcome: "critical_success" },
+    { label: "critical_failure", count: 1, outcome: "critical_failure" },
+];
+/** Rejection sampling over a secret persisted seed; independent per tool call. */
+export function seededRandom(seed, identity) {
+    let counter = 0;
+    return (maximum) => {
+        if (!Number.isSafeInteger(maximum) || maximum < 1 || maximum > 1_000_000)
+            throw new Error("Invalid random bound");
+        const limit = Math.floor(0x1_0000_0000 / maximum) * maximum;
+        for (;;) {
+            const value = createHmac("sha256", seed)
+                .update(JSON.stringify([identity, counter++]))
+                .digest()
+                .readUInt32BE();
+            if (value < limit)
+                return value % maximum;
+        }
+    };
+}
+/** Resolve one validated tool call. Invalid arguments throw before any draw. */
+export function resolveTabletop(name, args, random) {
+    if (!validators[name](args))
+        throw new Error(`Invalid ${name} parameters: ${ajv.errorsText(validators[name].errors)}`);
+    const input = args;
+    const receipt = name === "d20_check"
+        ? resolveD20(input, random)
+        : name === "percentile_check"
+            ? resolveD100(input, random)
+            : name === "bag_check"
+                ? resolveBag(input, random)
+                : name === "roll_dice"
+                    ? resolveDice(input, random)
+                    : resolveArithmetic(input);
+    if (!isResolutionReceipt(receipt))
+        throw new Error("Calculation produced an invalid resolution receipt");
+    return receipt;
+}
+function roll(random, sides) {
+    return random(sides) + 1;
+}
+function resolveD20(input, random) {
+    const mode = input.mode ?? "normal";
+    const modifier = input.modifier;
+    const difficulty = input.difficulty;
+    const dice = [roll(random, 20)];
+    if (mode !== "normal")
+        dice.push(roll(random, 20));
+    const selected = mode === "disadvantage" ? Math.min(...dice) : Math.max(...dice);
+    const total = selected + modifier;
+    return {
+        kind: "d20",
+        goal: input.goal,
+        modifier,
+        difficulty,
+        mode,
+        dice,
+        selected,
+        total,
+        margin: total - difficulty,
+        outcome: d20Outcome(selected, total, difficulty),
+    };
+}
+function resolveD100(input, random) {
+    const bonusDice = input.bonusDice ?? 0;
+    const penaltyDice = input.penaltyDice ?? 0;
+    const target = input.target;
+    const units = random(10);
+    const net = bonusDice - penaltyDice;
+    const tens = Array.from({ length: Math.abs(net) + 1 }, () => random(10));
+    const candidates = tens.map((ten) => percentileCandidate(ten, units));
+    const selected = net < 0 ? Math.max(...candidates) : Math.min(...candidates);
+    return {
+        kind: "d100",
+        goal: input.goal,
+        target,
+        bonusDice,
+        penaltyDice,
+        units,
+        tens,
+        candidates,
+        selected,
+        margin: target - selected,
+        outcome: d100Outcome(selected, target),
+    };
+}
+function resolveBag(input, random) {
+    const defaultBag = input.tokens === undefined;
+    const tokens = structuredClone(input.tokens ?? defaultBagTokens);
+    if (new Set(tokens.map((token) => token.label)).size !== tokens.length ||
+        tokens.some((token) => (token.modifier !== undefined) === (token.outcome !== undefined)))
+        throw new Error("Bag labels must be unique, with exactly one modifier or outcome per token");
+    const weight = tokens.reduce((sum, token) => sum + token.count, 0);
+    let index = random(weight);
+    const token = tokens.find((item) => {
+        index -= item.count;
+        return index < 0;
+    });
+    const value = input.value;
+    const difficulty = input.difficulty;
+    const base = {
+        kind: "bag",
+        goal: input.goal,
+        value,
+        difficulty,
+        defaultBag,
+        tokens,
+    };
+    if (token.outcome !== undefined)
+        return {
+            ...base,
+            drawn: { label: token.label, outcome: token.outcome },
+            outcome: token.outcome,
+        };
+    const drawn = { label: token.label, modifier: token.modifier };
+    const total = value + token.modifier;
+    return {
+        ...base,
+        drawn,
+        total,
+        margin: total - difficulty,
+        outcome: total >= difficulty ? "success" : "failure",
+    };
+}
+function resolveDice(input, random) {
+    const count = input.count;
+    const sides = input.sides;
+    const modifier = input.modifier ?? 0;
+    const dice = Array.from({ length: count }, () => roll(random, sides));
+    return {
+        kind: "dice",
+        goal: input.goal,
+        count,
+        sides,
+        modifier,
+        dice,
+        total: dice.reduce((sum, die) => sum + die, modifier),
+    };
+}
+function resolveArithmetic(input) {
+    const left = input.left;
+    const right = input.right;
+    const operation = input.operation;
+    if (operation === "divide" && right === 0)
+        throw new Error("Cannot divide by zero");
+    const total = arithmeticTotal(operation, left, right);
+    if (!Number.isFinite(total))
+        throw new Error("Calculation is not finite");
+    return {
+        kind: "arithmetic",
+        goal: input.goal,
+        left,
+        right,
+        operation,
+        total,
+    };
+}
+const outcomeLabels = {
+    "zh-CN": {
+        success: "成功",
+        failure: "失败",
+        critical_success: "大成功",
+        critical_failure: "大失败",
+    },
+    en: {
+        success: "success",
+        failure: "failure",
+        critical_success: "critical success",
+        critical_failure: "critical failure",
+    },
+};
+/** Localized text the model receives as the tool result. */
+export function resolutionMarkdown(receipt, locale) {
+    const zh = locale === "zh-CN";
+    const outcome = (value) => outcomeLabels[zh ? "zh-CN" : "en"][value];
+    const signed = (value) => (value >= 0 ? `+${value}` : `${value}`);
+    const list = (values) => values.join(", ");
+    const lines = [`# ${receipt.goal}`, ""];
+    if (receipt.kind === "d20") {
+        const modes = zh
+            ? { normal: "普通", advantage: "优势", disadvantage: "劣势" }
+            : {
+                normal: "normal",
+                advantage: "advantage",
+                disadvantage: "disadvantage",
+            };
+        const compared = receipt.total >= receipt.difficulty ? ">=" : "<";
+        lines.push(zh
+            ? `判定：d20，${modes[receipt.mode]}`
+            : `Check: d20, ${modes[receipt.mode]}`, zh
+            ? `修正：${signed(receipt.modifier)}；难度：${receipt.difficulty}`
+            : `Modifier: ${signed(receipt.modifier)}; difficulty: ${receipt.difficulty}`, zh
+            ? `掷骰：${list(receipt.dice)}；取值：${receipt.selected}`
+            : `Dice: ${list(receipt.dice)}; selected: ${receipt.selected}`, zh
+            ? `计算：${receipt.selected} ${signed(receipt.modifier)} = ${receipt.total}；${receipt.total} ${compared} ${receipt.difficulty}；差值 ${signed(receipt.margin)}`
+            : `Calculation: ${receipt.selected} ${signed(receipt.modifier)} = ${receipt.total}; ${receipt.total} ${compared} ${receipt.difficulty}; margin ${signed(receipt.margin)}`);
+    }
+    else if (receipt.kind === "d100") {
+        const net = receipt.bonusDice - receipt.penaltyDice;
+        const pool = net === 0
+            ? zh
+                ? "无额外十位骰"
+                : "no extra tens die"
+            : net > 0
+                ? zh
+                    ? `奖励骰 ${receipt.bonusDice}、惩罚骰 ${receipt.penaltyDice}，相消后 ${net} 枚奖励骰，取低`
+                    : `${receipt.bonusDice} bonus and ${receipt.penaltyDice} penalty dice, net ${net} bonus die; lowest kept`
+                : zh
+                    ? `奖励骰 ${receipt.bonusDice}、惩罚骰 ${receipt.penaltyDice}，相消后 ${-net} 枚惩罚骰，取高`
+                    : `${receipt.bonusDice} bonus and ${receipt.penaltyDice} penalty dice, net ${-net} penalty die; highest kept`;
+        lines.push(zh ? `目标：${receipt.target}` : `Target: ${receipt.target}`, zh ? `判定：d100，${pool}` : `Check: d100, ${pool}`, zh
+            ? `个位：${receipt.units}；十位：${list(receipt.tens)}`
+            : `Units: ${receipt.units}; tens: ${list(receipt.tens)}`, zh
+            ? `完整结果：${list(receipt.candidates)}；取值：${receipt.selected}`
+            : `Complete results: ${list(receipt.candidates)}; selected: ${receipt.selected}`, zh
+            ? `计算：${receipt.selected} <= ${receipt.target}；差值 ${signed(receipt.margin)}`
+            : `Calculation: ${receipt.selected} <= ${receipt.target}; margin ${signed(receipt.margin)}`);
+    }
+    else if (receipt.kind === "bag") {
+        const tokens = receipt.tokens
+            .map((token) => `${token.label} ×${token.count}`)
+            .join(zh ? "、" : ", ");
+        lines.push(zh
+            ? `标记袋：${receipt.defaultBag ? "默认袋" : "自定义袋"}（${tokens}）`
+            : `Bag: ${receipt.defaultBag ? "default" : "custom"} (${tokens})`, zh
+            ? `抽取：${receipt.drawn.label}（有放回）`
+            : `Drawn: ${receipt.drawn.label} (with replacement)`);
+        if (receipt.drawn.outcome !== undefined)
+            lines.push(zh
+                ? `特殊标记直接决定结果：${outcome(receipt.drawn.outcome)}`
+                : `Special token decides the result: ${outcome(receipt.drawn.outcome)}`);
+        else {
+            const compared = receipt.total >= receipt.difficulty ? ">=" : "<";
+            lines.push(zh
+                ? `数值：${receipt.value}；标记修正：${signed(receipt.drawn.modifier)}；难度：${receipt.difficulty}`
+                : `Value: ${receipt.value}; token modifier: ${signed(receipt.drawn.modifier)}; difficulty: ${receipt.difficulty}`, zh
+                ? `计算：${receipt.value} ${signed(receipt.drawn.modifier)} = ${receipt.total}；${receipt.total} ${compared} ${receipt.difficulty}；差值 ${signed(receipt.margin)}`
+                : `Calculation: ${receipt.value} ${signed(receipt.drawn.modifier)} = ${receipt.total}; ${receipt.total} ${compared} ${receipt.difficulty}; margin ${signed(receipt.margin)}`);
+        }
+    }
+    else if (receipt.kind === "dice") {
+        lines.push(zh
+            ? `掷骰：${receipt.count}d${receipt.sides}，结果 ${list(receipt.dice)}，修正 ${signed(receipt.modifier)}`
+            : `Dice: ${receipt.count}d${receipt.sides}, results ${list(receipt.dice)}, modifier ${signed(receipt.modifier)}`, zh ? `合计：${receipt.total}` : `Total: ${receipt.total}`);
+    }
+    else {
+        lines.push(zh
+            ? `计算：${receipt.left} ${arithmeticSymbol(receipt.operation)} ${receipt.right} = ${receipt.total}`
+            : `Calculation: ${receipt.left} ${arithmeticSymbol(receipt.operation)} ${receipt.right} = ${receipt.total}`);
+    }
+    if (receipt.kind === "d20" ||
+        receipt.kind === "d100" ||
+        receipt.kind === "bag")
+        lines.push("", zh
+            ? `结果：${outcome(receipt.outcome)}`
+            : `Outcome: ${outcome(receipt.outcome)}`);
+    return lines.join("\n");
+}
+function arithmeticSymbol(operation) {
+    return { add: "+", subtract: "-", multiply: "×", divide: "÷" }[operation];
+}