@smthrs/harness 0.0.0-stage → 1.0.0-rc.3

package/dist/esm/internal/printChannel.js

@@ -0,0 +1,376 @@
+/**
+ * The print channel: how a REPL frame's `console.log` calls become the bytes
+ * its successor reads.
+ *
+ * Two jobs live here, and both were priced off the `rerun-r95repl` lane rather
+ * than chosen.
+ *
+ * Every number here is a count of UTF-8 bytes, which is what the frame bound
+ * and the retention ceiling both mean by "bytes": the notices this module writes
+ * carry a `…`, three bytes wide and one UTF-16 unit, and counting them in units
+ * put a frame one byte over its own ceiling.
+ *
+ * **Sharing the frame budget.** Statements used to cap independently at 4 KiB
+ * each, head-first, under a 16 KiB frame bound that almost nobody reached: 197
+ * of the lane's 357 printing frames had a statement cut, 191 of those while the
+ * frame bound sat mostly unspent, and 3.06 MB went to per-statement caps against
+ * 6 frames that ever reached the frame one. Head-first is the part that cost
+ * verdicts — `sympy__sympy-13878` fused one `console.log` of 38,928 bytes whose
+ * head was a Python deprecation banner, so what it lost was the tail: the result
+ * of a three-minute test suite the same frame had just paid for, and the `git
+ * diff` that would have shown it the edit was already in the tree. It re-ran
+ * that suite four frames later. So the statements of a frame share one budget,
+ * each is elided from the middle, and no ceiling moves: 16 KiB was the most a
+ * frame could deliver before and it is the most now.
+ *
+ * **Compacting a printed structure.** A result printed whole is mostly repeated
+ * keys — a grep hit names `file`, `line`, `text` once per match — so an array of
+ * matches renders as file groups with numbered hits and context; other records
+ * render as a table with the union of keys named once. It is keyed on the shape
+ * and nothing else — this module knows no flow. Repeated keys save bytes;
+ * sparse records with mostly distinct keys can cost more as a table.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+import { isRecord } from "@smthrs/canonical/Record";
+import * as CanonicalJson from "@smthrs/model/CanonicalJson";
+import * as bytes from "./bytes.js";
+import * as elide from "./elide.js";
+/**
+ * How many UTF-8 bytes of one frame's whole print buffer reach the next model turn.
+ *
+ * This is the only ceiling on the channel. A frame's statements *share* it:
+ * each is middle-elided to the share it is apportioned, and a statement short
+ * of its share hands the remainder back to the statements that are over theirs.
+ *
+ * They used to cap independently at 4 KiB each, head-first, and the r95repl
+ * lane priced that: 197 of its 357 printing frames had a statement cut, 191 of
+ * them while this frame budget sat mostly unspent, and 3.06 MB went to
+ * per-statement caps against 6 frames that ever reached this one. The
+ * `sympy__sympy-13878` run fused one `console.log` of 38,928 bytes; it was
+ * shown the first 4,096 and lost the tail, which held the result of a
+ * three-minute test suite the frame had already paid for. It ran that suite
+ * again four frames later. Sharing the budget shows that frame 16 KiB from both
+ * ends instead of 4 KiB from the head, and moves no ceiling: 16 KiB was the
+ * most a frame could ever deliver before, and it is the most now.
+ *
+ * Every elision is from the middle with the dropped byte count stated, because
+ * the head and the tail of a log are where it identifies itself, and the notices
+ * are reserved out of this budget before any of it is apportioned — so the
+ * assembled buffer is bounded outright and nothing has to shorten it a second
+ * time. Sized against the `recall` budget it replaces, and delivered once rather
+ * than re-rendered every frame.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export const printFrameBytes = 16 * 1024;
+/**
+ * The smallest UTF-8-byte share of {@link printFrameBytes} one print statement is given.
+ *
+ * A share below this is all notice and no value — a middle elision of 80 bytes
+ * says less than the sentence explaining it — so a frame that printed more
+ * statements than the budget can floor drops whole statements from the middle
+ * and states how many, rather than cutting every one of them to nothing. That
+ * is the same shape the frame bound already had, applied a statement at a time
+ * so nothing is cut mid-line.
+ *
+ * It bounds how many statements are *kept*, but it is not a division of the
+ * budget: how many a frame can carry is priced off the statements it actually
+ * printed, so a statement at or under this size is shown whole and costs only
+ * itself. Two hundred eight-byte lines cost eighteen hundred bytes and all two
+ * hundred survive; sixty statements of four times this size do not, and whole
+ * ones go from the middle rather than every one of them being cut to a notice.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export const printStatementFloor = 512;
+/**
+ * How many UTF-8 bytes of one frame's print buffer the host keeps while the cell still runs.
+ *
+ * {@link printFrameBytes} bounds what the model is shown; this bounds what the
+ * host holds to show it from, and the two are different numbers because they
+ * answer different questions. A cell printing in a loop hands the host one
+ * payload per statement, and every payload is copied out of the sandbox's heap
+ * and decoded before anything can judge it surplus, so the frame budget alone
+ * bounds the answer while leaving the work unbounded. Sixteen times the frame
+ * budget is far past any honest use and still a fixed ceiling: past it the
+ * payload is not read at all, and the count of what went unread is stated in the
+ * buffer rather than dropped in silence.
+ *
+ * A statement is held at no more than {@link printFrameBytes} — the two ends of
+ * it, with the size it had — because a whole frame's budget is the most any one
+ * statement could ever be shown. So this ceiling holds at least sixteen
+ * statements whatever a cell prints, and a cell that prints many small values
+ * reaches it only after hundreds of them.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export const printRetainedBytes = 256 * 1024;
+/**
+ * The fewest records an array needs before it is rendered as a table.
+ *
+ * Two rows do not repay a header line, and one row is not a table at all.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const tableRows = 3;
+/**
+ * What the model is told when a print was cut: the value is still bound.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const recall = "print a narrower slice of this value; it is still bound in the realm";
+const cell = (value) => typeof value === "string" && !value.includes("\n") && !value.includes("|")
+    ? value
+    : CanonicalJson.stringify(value);
+const isMatchLine = (value) => isRecord(value) && Object.keys(value).length === 2 &&
+    Number.isInteger(value.line) && typeof value.text === "string";
+const isMatchSymbol = (value) => isRecord(value) && Object.keys(value).length === 4 &&
+    typeof value.kind === "string" && typeof value.name === "string" &&
+    Number.isInteger(value.startLine) && Number.isInteger(value.endLine);
+const isMatch = (value) => isRecord(value) &&
+    typeof value.file === "string" && Number.isInteger(value.line) && typeof value.text === "string" &&
+    Object.keys(value).every((key) => ["file", "line", "text", "before", "after", "symbol"].includes(key)) &&
+    (!Object.hasOwn(value, "before") || Array.isArray(value.before) && value.before.every(isMatchLine)) &&
+    (!Object.hasOwn(value, "after") || Array.isArray(value.after) && value.after.every(isMatchLine)) &&
+    (!Object.hasOwn(value, "symbol") || isMatchSymbol(value.symbol));
+/** Renders nonempty match lists in consecutive file groups, using rg's line markers. */
+const matchList = (value) => {
+    if (!Array.isArray(value) || value.length === 0 || !value.every(isMatch))
+        return undefined;
+    const lines = [];
+    let previousFile;
+    let previousLine = 0;
+    for (const match of value) {
+        const before = match.before ?? [];
+        const after = match.after ?? [];
+        if (match.file !== previousFile)
+            lines.push(match.file);
+        else if ((before[0]?.line ?? match.line) > previousLine + 1)
+            lines.push("--");
+        for (const context of before)
+            lines.push(`${context.line}-${context.text}`);
+        const symbol = match.symbol;
+        const suffix = symbol === undefined ? "" : `  ‹${symbol.kind} ${symbol.name} ${symbol.startLine}-${symbol.endLine}›`;
+        lines.push(`${match.line}:${match.text}${suffix}`);
+        for (const context of after)
+            lines.push(`${context.line}-${context.text}`);
+        previousFile = match.file;
+        previousLine = after.at(-1)?.line ?? match.line;
+    }
+    return lines.join("\n");
+};
+/**
+ * Renders an array of records as a table, or nothing.
+ *
+ * Columns are the union of keys in first-seen order. An absent member is an
+ * empty cell; explicit null, empty arrays and empty objects stay `null`, `[]`
+ * and `{}`. Cells are the string itself where that is unambiguous — no newline,
+ * no column separator — and canonical JSON everywhere else. An empty string
+ * still looks absent, and a string spelling a JSON literal still looks like
+ * that value: this is a log rather than a wire format, so it is not paid for in
+ * quoting every cell.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const table = (value) => {
+    if (!Array.isArray(value) || value.length < tableRows)
+        return undefined;
+    if (!value.every((isRecord)))
+        return undefined;
+    const columns = [...new Set(value.flatMap((element) => Object.keys(element)))];
+    if (columns.length < 2)
+        return undefined;
+    const rows = value.map((element) => columns.map((column) => Object.hasOwn(element, column) ? cell(element[column]) : "").join(" | "));
+    return `${columns.join(" | ")}\n${rows.join("\n")}`;
+};
+/**
+ * Renders one printed JSON value compactly.
+ *
+ * A match list becomes numbered source lines; other records become a table.
+ * An object with exactly one such member becomes that object's other members
+ * as JSON, then the member's name, count and rendered list. An exact failed-call
+ * envelope becomes its code, message and optional hint. Everything else is
+ * canonical JSON as before.
+ *
+ * Tables save repeated keys but pay for every column boundary, including
+ * absent members. The three-row, two-column floor saves bytes for uniform
+ * records; it does not guarantee savings for sparse records. Rendering stays
+ * shape-based rather than comparing both encodings.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const render = (value) => {
+    // A string is itself, which is what `Cell.renderText` promises everywhere
+    // else the harness renders a projected value. The prelude sends a primitive
+    // string down the `text` side, so this arm answers only for a boxed one.
+    if (typeof value === "string")
+        return value;
+    const flat = matchList(value) ?? table(value);
+    if (flat !== undefined)
+        return flat;
+    if (!isRecord(value))
+        return CanonicalJson.stringify(value);
+    const error = value.error;
+    if (Object.keys(value).length === 2 && value.ok === false &&
+        isRecord(error) &&
+        typeof error.code === "string" && typeof error.message === "string" &&
+        Object.keys(error).every((key) => key === "code" || key === "message" || key === "hint") &&
+        (!Object.hasOwn(error, "hint") || typeof error.hint === "string")) {
+        return `failed (${error.code}): ${error.message}${Object.hasOwn(error, "hint") ? ` — hint: ${error.hint}` : ""}`;
+    }
+    const tabled = Object.entries(value).flatMap(([key, member]) => {
+        const rendered = matchList(member) ?? table(member);
+        return rendered === undefined ? [] : [[key, member, rendered]];
+    });
+    if (tabled.length !== 1)
+        return CanonicalJson.stringify(value);
+    const [key, member, rendered] = tabled[0];
+    const rest = Object.fromEntries(Object.entries(value).filter(([name]) => name !== key));
+    return `${Object.keys(rest).length === 0 ? "" : `${CanonicalJson.stringify(rest)}\n`}${key} (${member.length}):\n${rendered}`;
+};
+/**
+ * Apportions one budget across statements of the given sizes.
+ *
+ * Short statements take what they need and hand the remainder back, so a frame
+ * that printed one long value and three short ones spends the budget on the long
+ * one. Allocation runs shortest first, which is what makes the hand-back
+ * possible, and the result is in the order the sizes were given.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const shares = (sizes, budget) => {
+    const order = sizes.map((size, index) => ({ size, index })).sort((left, right) => left.size === right.size ? left.index - right.index : left.size - right.size);
+    const allotted = new Array(sizes.length).fill(0);
+    let remaining = budget;
+    let left = sizes.length;
+    for (const { index, size } of order) {
+        const fair = Math.floor(remaining / left);
+        const given = Math.min(size, fair);
+        allotted[index] = given;
+        remaining = remaining - given;
+        left = left - 1;
+    }
+    return allotted;
+};
+/** The line a frame writes about the statements it dropped whole. */
+const droppedNotice = (count) => `… ${count} print statements elided from the middle of this frame; the values are still bound in the realm.`;
+/** The line a frame writes about the statements the host never copied out. */
+const unreadNotice = (count) => `… ${count} further print statements were not kept: this frame printed more than the harness holds.`;
+/**
+ * What keeping one statement costs the budget: its floor, its notice, its newline.
+ *
+ * A statement at or under {@link printStatementFloor} costs only itself
+ * and no notice, because {@link buffer} shows it whole and a whole statement has
+ * nothing to say about what it lost. One over the floor is promised the floor,
+ * and the notice that shortening it prints is charged with it.
+ */
+const price = (statement) => Math.min(statement.bytes, printStatementFloor) +
+    (statement.bytes > printStatementFloor ? elide.noticeCost(statement.bytes, recall) : 0) + 1;
+/**
+ * How many of *these* statements a budget can keep at the floor, head first.
+ *
+ * A count of the statements in hand rather than a constant, because what a
+ * statement costs is what it is. Taken as `printFrameBytes / printStatementFloor`
+ * it was 32 whatever a frame printed, so a frame of two hundred eight-byte lines
+ * dropped a hundred and sixty-eight of them while fifteen of its sixteen
+ * kilobytes went unspent — the failure the shared budget exists to end,
+ * reintroduced one level up. Two hundred lines that cost nine bytes each cost
+ * eighteen hundred, and the budget keeps every one of them.
+ *
+ * The walk takes the head, then the tail, then the head again, which is the
+ * order {@link buffer} assembles them in, so a budget that affords an odd number
+ * spends the odd one on the earlier statement.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const capacity = (statements, budget) => {
+    let left = budget;
+    let kept = 0;
+    while (kept < statements.length) {
+        const statement = kept % 2 === 0 ? statements[kept / 2] : statements[statements.length - 1 - (kept - 1) / 2];
+        const cost = price(statement);
+        if (cost > left)
+            break;
+        left = left - cost;
+        kept = kept + 1;
+    }
+    return kept;
+};
+/**
+ * Assembles what a frame printed, bounded by {@link printFrameBytes}.
+ *
+ * `unread` is the count of statements the host stopped copying out of the realm
+ * because the frame had already handed over more than it holds. It is stated
+ * rather than dropped, because a buffer that simply stopped reads as a cell that
+ * simply stopped printing.
+ *
+ * The bound holds by construction rather than by a second pass over the result,
+ * because a second pass would cut a notice in half and that is the one thing a
+ * bound may not do. {@link capacity} charges every kept statement the floor it is
+ * promised, the notice it would print and its newline; what survives that walk is
+ * therefore affordable, and the apportionment below spends only what the walk
+ * left. A statement at or under the floor is shown whole and reserves no notice
+ * at all — reserving one apiece is what left a frame of short lines nothing to
+ * spend on the lines themselves.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const buffer = (statements, unread) => {
+    if (statements.length === 0 && unread === 0)
+        return "";
+    // The count-lines come out of the budget before the statements are counted,
+    // and the drop line only where there is a drop — so it is priced by asking
+    // twice, rather than by charging every frame for a line most never print.
+    const overhead = unread === 0 ? 0 : bytes.size(unreadNotice(unread)) + 1;
+    const roomy = capacity(statements, printFrameBytes - overhead);
+    const affordable = roomy === statements.length
+        ? roomy
+        : capacity(statements, printFrameBytes - overhead - bytes.size(droppedNotice(statements.length)) - 1);
+    // More statements than the budget can floor: whole statements go from the
+    // middle, counted, rather than every one of them being cut to a notice.
+    const head = Math.ceil(affordable / 2);
+    const kept = statements.length === affordable
+        ? statements
+        : [...statements.slice(0, head), ...statements.slice(statements.length - Math.floor(affordable / 2))];
+    const dropped = statements.length - kept.length;
+    const notices = [
+        ...(dropped === 0 ? [] : [droppedNotice(dropped)]),
+        ...(unread === 0 ? [] : [unreadNotice(unread)])
+    ];
+    // What the budget cannot spend on values: the count-lines, the newline between
+    // every pair, and one elision notice for each statement the floor does not
+    // cover whole.
+    const sizes = kept.map((statement) => statement.bytes);
+    const reserve = kept.reduce((sum, statement) => sum + (statement.bytes > printStatementFloor ? elide.noticeCost(statement.bytes, recall) : 0), 0) +
+        notices.reduce((sum, line) => sum + bytes.size(line), 0) +
+        Math.max(0, kept.length + notices.length - 1);
+    const allotted = shares(sizes, Math.max(0, printFrameBytes - reserve));
+    const lines = kept.map((statement, index) => elide.middleFrom(statement.text, statement.bytes, allotted[index], recall));
+    return [
+        ...lines.slice(0, dropped === 0 ? lines.length : head),
+        ...(dropped === 0 ? [] : [notices[0], ...lines.slice(head)]),
+        ...(unread === 0 ? [] : [notices[notices.length - 1]])
+    ].join("\n");
+};
+//# sourceMappingURL=printChannel.js.map

package/dist/esm/internal/printChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"printChannel.js","sourceRoot":"","sources":["../../../src/internal/printChannel.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The print channel: how a REPL frame's `console.log` calls become the bytes\n * its successor reads.\n *\n * Two jobs live here, and both were priced off the `rerun-r95repl` lane rather\n * than chosen.\n *\n * Every number here is a count of UTF-8 bytes, which is what the frame bound\n * and the retention ceiling both mean by \"bytes\": the notices this module writes\n * carry a `…`, three bytes wide and one UTF-16 unit, and counting them in units\n * put a frame one byte over its own ceiling.\n *\n * **Sharing the frame budget.** Statements used to cap independently at 4 KiB\n * each, head-first, under a 16 KiB frame bound that almost nobody reached: 197\n * of the lane's 357 printing frames had a statement cut, 191 of those while the\n * frame bound sat mostly unspent, and 3.06 MB went to per-statement caps against\n * 6 frames that ever reached the frame one. Head-first is the part that cost\n * verdicts — `sympy__sympy-13878` fused one `console.log` of 38,928 bytes whose\n * head was a Python deprecation banner, so what it lost was the tail: the result\n * of a three-minute test suite the same frame had just paid for, and the `git\n * diff` that would have shown it the edit was already in the tree. It re-ran\n * that suite four frames later. So the statements of a frame share one budget,\n * each is elided from the middle, and no ceiling moves: 16 KiB was the most a\n * frame could deliver before and it is the most now.\n *\n * **Compacting a printed structure.** A result printed whole is mostly repeated\n * keys — a grep hit names `file`, `line`, `text` once per match — so an array of\n * matches renders as file groups with numbered hits and context; other records\n * render as a table with the union of keys named once. It is keyed on the shape\n * and nothing else — this module knows no flow. Repeated keys save bytes;\n * sparse records with mostly distinct keys can cost more as a table.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\n\nimport { isRecord } from \"@smthrs/canonical/Record\"\nimport * as CanonicalJson from \"@smthrs/model/CanonicalJson\"\nimport type { Schema } from \"effect\"\nimport * as bytes from \"./bytes.ts\"\nimport * as elide from \"./elide.ts\"\n\n/**\n * How many UTF-8 bytes of one frame's whole print buffer reach the next model turn.\n *\n * This is the only ceiling on the channel. A frame's statements *share* it:\n * each is middle-elided to the share it is apportioned, and a statement short\n * of its share hands the remainder back to the statements that are over theirs.\n *\n * They used to cap independently at 4 KiB each, head-first, and the r95repl\n * lane priced that: 197 of its 357 printing frames had a statement cut, 191 of\n * them while this frame budget sat mostly unspent, and 3.06 MB went to\n * per-statement caps against 6 frames that ever reached this one. The\n * `sympy__sympy-13878` run fused one `console.log` of 38,928 bytes; it was\n * shown the first 4,096 and lost the tail, which held the result of a\n * three-minute test suite the frame had already paid for. It ran that suite\n * again four frames later. Sharing the budget shows that frame 16 KiB from both\n * ends instead of 4 KiB from the head, and moves no ceiling: 16 KiB was the\n * most a frame could ever deliver before, and it is the most now.\n *\n * Every elision is from the middle with the dropped byte count stated, because\n * the head and the tail of a log are where it identifies itself, and the notices\n * are reserved out of this budget before any of it is apportioned — so the\n * assembled buffer is bounded outright and nothing has to shorten it a second\n * time. Sized against the `recall` budget it replaces, and delivered once rather\n * than re-rendered every frame.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const printFrameBytes = 16 * 1024\n\n/**\n * The smallest UTF-8-byte share of {@link printFrameBytes} one print statement is given.\n *\n * A share below this is all notice and no value — a middle elision of 80 bytes\n * says less than the sentence explaining it — so a frame that printed more\n * statements than the budget can floor drops whole statements from the middle\n * and states how many, rather than cutting every one of them to nothing. That\n * is the same shape the frame bound already had, applied a statement at a time\n * so nothing is cut mid-line.\n *\n * It bounds how many statements are *kept*, but it is not a division of the\n * budget: how many a frame can carry is priced off the statements it actually\n * printed, so a statement at or under this size is shown whole and costs only\n * itself. Two hundred eight-byte lines cost eighteen hundred bytes and all two\n * hundred survive; sixty statements of four times this size do not, and whole\n * ones go from the middle rather than every one of them being cut to a notice.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const printStatementFloor = 512\n\n/**\n * How many UTF-8 bytes of one frame's print buffer the host keeps while the cell still runs.\n *\n * {@link printFrameBytes} bounds what the model is shown; this bounds what the\n * host holds to show it from, and the two are different numbers because they\n * answer different questions. A cell printing in a loop hands the host one\n * payload per statement, and every payload is copied out of the sandbox's heap\n * and decoded before anything can judge it surplus, so the frame budget alone\n * bounds the answer while leaving the work unbounded. Sixteen times the frame\n * budget is far past any honest use and still a fixed ceiling: past it the\n * payload is not read at all, and the count of what went unread is stated in the\n * buffer rather than dropped in silence.\n *\n * A statement is held at no more than {@link printFrameBytes} — the two ends of\n * it, with the size it had — because a whole frame's budget is the most any one\n * statement could ever be shown. So this ceiling holds at least sixteen\n * statements whatever a cell prints, and a cell that prints many small values\n * reaches it only after hundreds of them.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const printRetainedBytes = 256 * 1024\n\n/**\n * The fewest records an array needs before it is rendered as a table.\n *\n * Two rows do not repay a header line, and one row is not a table at all.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const tableRows = 3\n\n/**\n * What the model is told when a print was cut: the value is still bound.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const recall = \"print a narrower slice of this value; it is still bound in the realm\"\n\n/**\n * One `console.log` call, as the host kept it.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface Statement {\n  /** The head and tail the host kept, in order and possibly the whole thing. */\n  readonly text: string\n  /** What the statement rendered to before anything was dropped. */\n  readonly bytes: number\n}\n\nconst cell = (value: Schema.Json): string =>\n  typeof value === \"string\" && !value.includes(\"\\n\") && !value.includes(\"|\")\n    ? value\n    : CanonicalJson.stringify(value)\n\n/** A source line, shared by hits and their context. */\ntype MatchLine = { readonly line: number; readonly text: string }\n\n/** The optional symbol attached to a source hit. */\ntype MatchSymbol = {\n  readonly kind: string\n  readonly name: string\n  readonly startLine: number\n  readonly endLine: number\n}\n\n/** The exact match shape; additional data must survive in the generic table. */\ntype Match = MatchLine & {\n  readonly file: string\n  readonly before?: ReadonlyArray<MatchLine>\n  readonly after?: ReadonlyArray<MatchLine>\n  readonly symbol?: MatchSymbol\n}\n\nconst isMatchLine = (value: Schema.Json): value is MatchLine =>\n  isRecord<Schema.Json>(value) && Object.keys(value).length === 2 &&\n  Number.isInteger(value.line) && typeof value.text === \"string\"\n\nconst isMatchSymbol = (value: Schema.Json | undefined): value is MatchSymbol =>\n  isRecord<Schema.Json>(value) && Object.keys(value).length === 4 &&\n  typeof value.kind === \"string\" && typeof value.name === \"string\" &&\n  Number.isInteger(value.startLine) && Number.isInteger(value.endLine)\n\nconst isMatch = (value: Schema.Json): value is Match =>\n  isRecord<Schema.Json>(value) &&\n  typeof value.file === \"string\" && Number.isInteger(value.line) && typeof value.text === \"string\" &&\n  Object.keys(value).every((key) => [\"file\", \"line\", \"text\", \"before\", \"after\", \"symbol\"].includes(key)) &&\n  (!Object.hasOwn(value, \"before\") || Array.isArray(value.before) && value.before.every(isMatchLine)) &&\n  (!Object.hasOwn(value, \"after\") || Array.isArray(value.after) && value.after.every(isMatchLine)) &&\n  (!Object.hasOwn(value, \"symbol\") || isMatchSymbol(value.symbol))\n\n/** Renders nonempty match lists in consecutive file groups, using rg's line markers. */\nconst matchList = (value: Schema.Json): string | undefined => {\n  if (!Array.isArray(value) || value.length === 0 || !value.every(isMatch)) return undefined\n  const lines: Array<string> = []\n  let previousFile: string | undefined\n  let previousLine = 0\n  for (const match of value) {\n    const before = match.before ?? []\n    const after = match.after ?? []\n    if (match.file !== previousFile) lines.push(match.file)\n    else if ((before[0]?.line ?? match.line) > previousLine + 1) lines.push(\"--\")\n    for (const context of before) lines.push(`${context.line}-${context.text}`)\n    const symbol = match.symbol\n    const suffix = symbol === undefined ? \"\" : `  ‹${symbol.kind} ${symbol.name} ${symbol.startLine}-${symbol.endLine}›`\n    lines.push(`${match.line}:${match.text}${suffix}`)\n    for (const context of after) lines.push(`${context.line}-${context.text}`)\n    previousFile = match.file\n    previousLine = after.at(-1)?.line ?? match.line\n  }\n  return lines.join(\"\\n\")\n}\n\n/**\n * Renders an array of records as a table, or nothing.\n *\n * Columns are the union of keys in first-seen order. An absent member is an\n * empty cell; explicit null, empty arrays and empty objects stay `null`, `[]`\n * and `{}`. Cells are the string itself where that is unambiguous — no newline,\n * no column separator — and canonical JSON everywhere else. An empty string\n * still looks absent, and a string spelling a JSON literal still looks like\n * that value: this is a log rather than a wire format, so it is not paid for in\n * quoting every cell.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const table = (value: Schema.Json): string | undefined => {\n  if (!Array.isArray(value) || value.length < tableRows) return undefined\n  if (!value.every(isRecord<Schema.Json>)) return undefined\n  const columns = [...new Set(value.flatMap((element) => Object.keys(element)))]\n  if (columns.length < 2) return undefined\n  const rows = value.map((element) =>\n    columns.map((column) => Object.hasOwn(element, column) ? cell(element[column]!) : \"\").join(\" | \")\n  )\n  return `${columns.join(\" | \")}\\n${rows.join(\"\\n\")}`\n}\n\n/**\n * Renders one printed JSON value compactly.\n *\n * A match list becomes numbered source lines; other records become a table.\n * An object with exactly one such member becomes that object's other members\n * as JSON, then the member's name, count and rendered list. An exact failed-call\n * envelope becomes its code, message and optional hint. Everything else is\n * canonical JSON as before.\n *\n * Tables save repeated keys but pay for every column boundary, including\n * absent members. The three-row, two-column floor saves bytes for uniform\n * records; it does not guarantee savings for sparse records. Rendering stays\n * shape-based rather than comparing both encodings.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const render = (value: Schema.Json): string => {\n  // A string is itself, which is what `Cell.renderText` promises everywhere\n  // else the harness renders a projected value. The prelude sends a primitive\n  // string down the `text` side, so this arm answers only for a boxed one.\n  if (typeof value === \"string\") return value\n  const flat = matchList(value) ?? table(value)\n  if (flat !== undefined) return flat\n  if (!isRecord<Schema.Json>(value)) return CanonicalJson.stringify(value)\n  const error = value.error\n  if (\n    Object.keys(value).length === 2 && value.ok === false &&\n    isRecord<Schema.Json>(error) &&\n    typeof error.code === \"string\" && typeof error.message === \"string\" &&\n    Object.keys(error).every((key) => key === \"code\" || key === \"message\" || key === \"hint\") &&\n    (!Object.hasOwn(error, \"hint\") || typeof error.hint === \"string\")\n  ) {\n    return `failed (${error.code}): ${error.message}${Object.hasOwn(error, \"hint\") ? ` — hint: ${error.hint}` : \"\"}`\n  }\n  const tabled = Object.entries(value).flatMap(([key, member]) => {\n    const rendered = matchList(member) ?? table(member)\n    return rendered === undefined ? [] : [[key, member as ReadonlyArray<unknown>, rendered] as const]\n  })\n  if (tabled.length !== 1) return CanonicalJson.stringify(value)\n  const [key, member, rendered] = tabled[0]!\n  const rest = Object.fromEntries(Object.entries(value).filter(([name]) => name !== key))\n  return `${\n    Object.keys(rest).length === 0 ? \"\" : `${CanonicalJson.stringify(rest)}\\n`\n  }${key} (${member.length}):\\n${rendered}`\n}\n\n/**\n * Apportions one budget across statements of the given sizes.\n *\n * Short statements take what they need and hand the remainder back, so a frame\n * that printed one long value and three short ones spends the budget on the long\n * one. Allocation runs shortest first, which is what makes the hand-back\n * possible, and the result is in the order the sizes were given.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const shares = (sizes: ReadonlyArray<number>, budget: number): ReadonlyArray<number> => {\n  const order = sizes.map((size, index) => ({ size, index })).sort((left, right) =>\n    left.size === right.size ? left.index - right.index : left.size - right.size\n  )\n  const allotted = new Array<number>(sizes.length).fill(0)\n  let remaining = budget\n  let left = sizes.length\n  for (const { index, size } of order) {\n    const fair = Math.floor(remaining / left)\n    const given = Math.min(size, fair)\n    allotted[index] = given\n    remaining = remaining - given\n    left = left - 1\n  }\n  return allotted\n}\n\n/** The line a frame writes about the statements it dropped whole. */\nconst droppedNotice = (count: number): string =>\n  `… ${count} print statements elided from the middle of this frame; the values are still bound in the realm.`\n\n/** The line a frame writes about the statements the host never copied out. */\nconst unreadNotice = (count: number): string =>\n  `… ${count} further print statements were not kept: this frame printed more than the harness holds.`\n\n/**\n * What keeping one statement costs the budget: its floor, its notice, its newline.\n *\n * A statement at or under {@link printStatementFloor} costs only itself\n * and no notice, because {@link buffer} shows it whole and a whole statement has\n * nothing to say about what it lost. One over the floor is promised the floor,\n * and the notice that shortening it prints is charged with it.\n */\nconst price = (statement: Statement): number =>\n  Math.min(statement.bytes, printStatementFloor) +\n  (statement.bytes > printStatementFloor ? elide.noticeCost(statement.bytes, recall) : 0) + 1\n\n/**\n * How many of *these* statements a budget can keep at the floor, head first.\n *\n * A count of the statements in hand rather than a constant, because what a\n * statement costs is what it is. Taken as `printFrameBytes / printStatementFloor`\n * it was 32 whatever a frame printed, so a frame of two hundred eight-byte lines\n * dropped a hundred and sixty-eight of them while fifteen of its sixteen\n * kilobytes went unspent — the failure the shared budget exists to end,\n * reintroduced one level up. Two hundred lines that cost nine bytes each cost\n * eighteen hundred, and the budget keeps every one of them.\n *\n * The walk takes the head, then the tail, then the head again, which is the\n * order {@link buffer} assembles them in, so a budget that affords an odd number\n * spends the odd one on the earlier statement.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const capacity = (statements: ReadonlyArray<Statement>, budget: number): number => {\n  let left = budget\n  let kept = 0\n  while (kept < statements.length) {\n    const statement = kept % 2 === 0 ? statements[kept / 2]! : statements[statements.length - 1 - (kept - 1) / 2]!\n    const cost = price(statement)\n    if (cost > left) break\n    left = left - cost\n    kept = kept + 1\n  }\n  return kept\n}\n\n/**\n * Assembles what a frame printed, bounded by {@link printFrameBytes}.\n *\n * `unread` is the count of statements the host stopped copying out of the realm\n * because the frame had already handed over more than it holds. It is stated\n * rather than dropped, because a buffer that simply stopped reads as a cell that\n * simply stopped printing.\n *\n * The bound holds by construction rather than by a second pass over the result,\n * because a second pass would cut a notice in half and that is the one thing a\n * bound may not do. {@link capacity} charges every kept statement the floor it is\n * promised, the notice it would print and its newline; what survives that walk is\n * therefore affordable, and the apportionment below spends only what the walk\n * left. A statement at or under the floor is shown whole and reserves no notice\n * at all — reserving one apiece is what left a frame of short lines nothing to\n * spend on the lines themselves.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const buffer = (statements: ReadonlyArray<Statement>, unread: number): string => {\n  if (statements.length === 0 && unread === 0) return \"\"\n  // The count-lines come out of the budget before the statements are counted,\n  // and the drop line only where there is a drop — so it is priced by asking\n  // twice, rather than by charging every frame for a line most never print.\n  const overhead = unread === 0 ? 0 : bytes.size(unreadNotice(unread)) + 1\n  const roomy = capacity(statements, printFrameBytes - overhead)\n  const affordable = roomy === statements.length\n    ? roomy\n    : capacity(statements, printFrameBytes - overhead - bytes.size(droppedNotice(statements.length)) - 1)\n  // More statements than the budget can floor: whole statements go from the\n  // middle, counted, rather than every one of them being cut to a notice.\n  const head = Math.ceil(affordable / 2)\n  const kept = statements.length === affordable\n    ? statements\n    : [...statements.slice(0, head), ...statements.slice(statements.length - Math.floor(affordable / 2))]\n  const dropped = statements.length - kept.length\n  const notices = [\n    ...(dropped === 0 ? [] : [droppedNotice(dropped)]),\n    ...(unread === 0 ? [] : [unreadNotice(unread)])\n  ]\n  // What the budget cannot spend on values: the count-lines, the newline between\n  // every pair, and one elision notice for each statement the floor does not\n  // cover whole.\n  const sizes = kept.map((statement) => statement.bytes)\n  const reserve = kept.reduce(\n    (sum, statement) => sum + (statement.bytes > printStatementFloor ? elide.noticeCost(statement.bytes, recall) : 0),\n    0\n  ) +\n    notices.reduce((sum, line) => sum + bytes.size(line), 0) +\n    Math.max(0, kept.length + notices.length - 1)\n  const allotted = shares(sizes, Math.max(0, printFrameBytes - reserve))\n  const lines = kept.map((statement, index) =>\n    elide.middleFrom(statement.text, statement.bytes, allotted[index]!, recall)\n  )\n  return [\n    ...lines.slice(0, dropped === 0 ? lines.length : head),\n    ...(dropped === 0 ? [] : [notices[0]!, ...lines.slice(head)]),\n    ...(unread === 0 ? [] : [notices[notices.length - 1]!])\n  ].join(\"\\n\")\n}\n"]}

package/dist/esm/internal/printsObservation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The one rendering of a frame's print buffer into the turn that reads it.
+ *
+ * The controller journals the RAW buffer as `AgentEvent.CellPrinted` and sends
+ * this rendering to the model, so a projection that replays the raw text
+ * rebuilds a window the run never had. Both callers go through here for that
+ * reason: `CellTurn` when it builds the next turn, and `Transcript` when it
+ * rebuilds one from the journal.
+ *
+ * An empty buffer is a message and not a silence. A cell that printed nothing
+ * still opened a turn, and the turn it opened says so — dropping it loses a
+ * user message the model actually read, and the model is told the realm still
+ * holds everything the cell bound, which is the recovery it needs.
+ *
+ * @since 0.1.0
+ * @private
+ */
+/**
+ * Renders one frame's print buffer as the user turn its successor read.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @private
+ */
+export declare const printsObservation: (prints: string) => string;
+//# sourceMappingURL=printsObservation.d.ts.map

package/dist/esm/internal/printsObservation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printsObservation.d.ts","sourceRoot":"","sources":["../../../src/internal/printsObservation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,KAAG,MAGoE,CAAA"}

package/dist/esm/internal/printsObservation.js

@@ -0,0 +1,29 @@
+/**
+ * The one rendering of a frame's print buffer into the turn that reads it.
+ *
+ * The controller journals the RAW buffer as `AgentEvent.CellPrinted` and sends
+ * this rendering to the model, so a projection that replays the raw text
+ * rebuilds a window the run never had. Both callers go through here for that
+ * reason: `CellTurn` when it builds the next turn, and `Transcript` when it
+ * rebuilds one from the journal.
+ *
+ * An empty buffer is a message and not a silence. A cell that printed nothing
+ * still opened a turn, and the turn it opened says so — dropping it loses a
+ * user message the model actually read, and the model is told the realm still
+ * holds everything the cell bound, which is the recovery it needs.
+ *
+ * @since 0.1.0
+ * @private
+ */
+import { untrustedData } from "./untrustedData.js";
+/**
+ * Renders one frame's print buffer as the user turn its successor read.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @private
+ */
+export const printsObservation = (prints) => prints === ""
+    ? "Your cell printed nothing, so this turn opens with nothing new to read. Everything it bound is still in the realm; print what you need to look at."
+    : untrustedData(`What your cell printed:\n${prints}`, "cell print buffer (may contain repository and tool output)");
+//# sourceMappingURL=printsObservation.js.map

package/dist/esm/internal/printsObservation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"printsObservation.js","sourceRoot":"","sources":["../../../src/internal/printsObservation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,MAAc,EAAU,EAAE,CAC1D,MAAM,KAAK,EAAE;IACX,CAAC,CAAC,oJAAoJ;IACtJ,CAAC,CAAC,aAAa,CAAC,4BAA4B,MAAM,EAAE,EAAE,4DAA4D,CAAC,CAAA","sourcesContent":["/**\n * The one rendering of a frame's print buffer into the turn that reads it.\n *\n * The controller journals the RAW buffer as `AgentEvent.CellPrinted` and sends\n * this rendering to the model, so a projection that replays the raw text\n * rebuilds a window the run never had. Both callers go through here for that\n * reason: `CellTurn` when it builds the next turn, and `Transcript` when it\n * rebuilds one from the journal.\n *\n * An empty buffer is a message and not a silence. A cell that printed nothing\n * still opened a turn, and the turn it opened says so — dropping it loses a\n * user message the model actually read, and the model is told the realm still\n * holds everything the cell bound, which is the recovery it needs.\n *\n * @since 0.1.0\n * @private\n */\n\nimport { untrustedData } from \"./untrustedData.ts\"\n\n/**\n * Renders one frame's print buffer as the user turn its successor read.\n *\n * @category conversions\n * @since 0.1.0\n * @private\n */\nexport const printsObservation = (prints: string): string =>\n  prints === \"\"\n    ? \"Your cell printed nothing, so this turn opens with nothing new to read. Everything it bound is still in the realm; print what you need to look at.\"\n    : untrustedData(`What your cell printed:\\n${prints}`, \"cell print buffer (may contain repository and tool output)\")\n"]}

package/dist/esm/internal/refusal.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The one constructor for a refusal a cell observes as a resolved envelope.
+ *
+ * A failed call **resolves** with a `failure` `Cell.CallResult`; it does not
+ * throw, and `Cell.callFailure` renders it as `{ ok: false, error }`. The shape
+ * is fixed — `value` is `null`, because a refusal has no value to hand back,
+ * except a timeout's, which records the limit it ran past (see {@link timedOut})
+ * — so every boundary that refuses a call builds it here rather than repeating
+ * the literal. The cell never sees `value` on a failure. An absent `code` is left absent rather than written as
+ * `undefined`: the encoded result is the durable wire contract used in sealed
+ * keys, and it means {@link Cell.defaultCallFailureCode}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+import { type CallFailureCode, CallResult } from "../Cell.ts";
+/**
+ * A refusal the cell observes as a resolved `{ ok: false, error }` envelope.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const refusal: (code: CallFailureCode | undefined, message: string) => CallResult;
+/**
+ * A timeout refusal: the `timeout` code, with the limit the call ran past
+ * recorded as `{ limitMillis }` in `value`, so a host that guards timeouts
+ * parks the run on the exact limit whichever clock enforced it.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const timedOut: (message: string, limitMillis: number) => CallResult;
+/**
+ * The limit a {@link timedOut} refusal recorded, when it recorded one.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const limitOf: (result: CallResult) => number | undefined;
+//# sourceMappingURL=refusal.d.ts.map

package/dist/esm/internal/refusal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusal.d.ts","sourceRoot":"","sources":["../../../src/internal/refusal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,eAAe,GAAG,SAAS,EAAE,SAAS,MAAM,KAAG,UAGL,CAAA;AAExE;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,MAAM,EAAE,aAAa,MAAM,KAAG,UAC0B,CAAA;AAE1F;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,QAAQ,UAAU,KAAG,MAAM,GAAG,SAGrD,CAAA"}

package/dist/esm/internal/refusal.js

@@ -0,0 +1,47 @@
+/**
+ * The one constructor for a refusal a cell observes as a resolved envelope.
+ *
+ * A failed call **resolves** with a `failure` `Cell.CallResult`; it does not
+ * throw, and `Cell.callFailure` renders it as `{ ok: false, error }`. The shape
+ * is fixed — `value` is `null`, because a refusal has no value to hand back,
+ * except a timeout's, which records the limit it ran past (see {@link timedOut})
+ * — so every boundary that refuses a call builds it here rather than repeating
+ * the literal. The cell never sees `value` on a failure. An absent `code` is left absent rather than written as
+ * `undefined`: the encoded result is the durable wire contract used in sealed
+ * keys, and it means {@link Cell.defaultCallFailureCode}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+import * as Schema from "effect/Schema";
+import { CallResult } from "../Cell.js";
+/**
+ * A refusal the cell observes as a resolved `{ ok: false, error }` envelope.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const refusal = (code, message) => code === undefined
+    ? new CallResult({ outcome: "failure", value: null, message })
+    : new CallResult({ outcome: "failure", value: null, code, message });
+/**
+ * A timeout refusal: the `timeout` code, with the limit the call ran past
+ * recorded as `{ limitMillis }` in `value`, so a host that guards timeouts
+ * parks the run on the exact limit whichever clock enforced it.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export const timedOut = (message, limitMillis) => new CallResult({ outcome: "failure", value: { limitMillis }, code: "timeout", message });
+/**
+ * The limit a {@link timedOut} refusal recorded, when it recorded one.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export const limitOf = (result) => {
+    const recorded = decodeLimit(result.value);
+    return recorded._tag === "Success" ? recorded.success.limitMillis : undefined;
+};
+const decodeLimit = Schema.decodeUnknownResult(Schema.Struct({ limitMillis: Schema.Number }));
+//# sourceMappingURL=refusal.js.map

package/dist/esm/internal/refusal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusal.js","sourceRoot":"","sources":["../../../src/internal/refusal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAwB,UAAU,EAAE,MAAM,YAAY,CAAA;AAE7D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,IAAiC,EAAE,OAAe,EAAc,EAAE,CACxF,IAAI,KAAK,SAAS;IAChB,CAAC,CAAC,IAAI,UAAU,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC9D,CAAC,CAAC,IAAI,UAAU,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAA;AAExE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,OAAe,EAAE,WAAmB,EAAc,EAAE,CAC3E,IAAI,UAAU,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAA;AAE1F;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,MAAkB,EAAsB,EAAE;IAChE,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC1C,OAAO,QAAQ,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAA;AAC/E,CAAC,CAAA;AAED,MAAM,WAAW,GAAG,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA","sourcesContent":["/**\n * The one constructor for a refusal a cell observes as a resolved envelope.\n *\n * A failed call **resolves** with a `failure` `Cell.CallResult`; it does not\n * throw, and `Cell.callFailure` renders it as `{ ok: false, error }`. The shape\n * is fixed — `value` is `null`, because a refusal has no value to hand back,\n * except a timeout's, which records the limit it ran past (see {@link timedOut})\n * — so every boundary that refuses a call builds it here rather than repeating\n * the literal. The cell never sees `value` on a failure. An absent `code` is left absent rather than written as\n * `undefined`: the encoded result is the durable wire contract used in sealed\n * keys, and it means {@link Cell.defaultCallFailureCode}.\n *\n * @since 1.0.0-rc.0\n * @private\n */\n\nimport * as Schema from \"effect/Schema\"\nimport { type CallFailureCode, CallResult } from \"../Cell.ts\"\n\n/**\n * A refusal the cell observes as a resolved `{ ok: false, error }` envelope.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const refusal = (code: CallFailureCode | undefined, message: string): CallResult =>\n  code === undefined\n    ? new CallResult({ outcome: \"failure\", value: null, message })\n    : new CallResult({ outcome: \"failure\", value: null, code, message })\n\n/**\n * A timeout refusal: the `timeout` code, with the limit the call ran past\n * recorded as `{ limitMillis }` in `value`, so a host that guards timeouts\n * parks the run on the exact limit whichever clock enforced it.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const timedOut = (message: string, limitMillis: number): CallResult =>\n  new CallResult({ outcome: \"failure\", value: { limitMillis }, code: \"timeout\", message })\n\n/**\n * The limit a {@link timedOut} refusal recorded, when it recorded one.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const limitOf = (result: CallResult): number | undefined => {\n  const recorded = decodeLimit(result.value)\n  return recorded._tag === \"Success\" ? recorded.success.limitMillis : undefined\n}\n\nconst decodeLimit = Schema.decodeUnknownResult(Schema.Struct({ limitMillis: Schema.Number }))\n"]}