primitive-admin 1.1.0-alpha.82 → 1.1.0-alpha.83

package/dist/src/lib/function-log-lines.d.ts

@@ -0,0 +1,76 @@
+/**
+ * One invocation's captured console output, in the order it was printed —
+ * #3453 (D3453-005).
+ *
+ * `primitive functions logs --run <run-id>` used to print the same one-row-per
+ * record table the listing prints, so the LINES — the thing an operator opened
+ * the logs for — were only reachable through `--json`. This renders them, under
+ * the step that wrote them.
+ *
+ * Pure, and separate from the command, for the reason `function-log-row.ts`
+ * gives: a rendering rule that lives inside an action can only be tested by
+ * spawning the CLI, and this one has enough cases (two orderings, a header that
+ * changes, a throw, a pre-change record) that spawning for each would be the
+ * wrong trade.
+ */
+/** The marker a truncated record ends with, so loss is never silent. */
+export declare const TRUNCATION_MARKER = "\u2026 truncated: the platform's per-record cap dropped later lines";
+/**
+ * What an EMPTY record whose attempt ended in the engine says — #3564,
+ * criterion 2 (D3564-007).
+ *
+ * The filing's own complaint: the invocation log held no console output for
+ * these attempts, with `truncated`, `logsUnavailable` and `contentSuppressed`
+ * all unset, so the silence read as "logs lost" when it meant "the handler
+ * printed nothing before the engine took the isolate away". This renderer
+ * printed nothing at all for such a record, which is the reading the filing
+ * asks to be able to make.
+ *
+ * Two facts, never collapsed into one: the first half says the attempt ended
+ * in the engine, and the SECOND half is chosen by the drain's own flags. A
+ * drain that failed — which `DrainedLogs.unavailable` names isolate eviction
+ * as a cause of — is reported as unavailable rather than as an empty handler,
+ * because those are opposite statements and this is precisely the case where
+ * guessing would be wrong.
+ */
+export declare const ENGINE_END_PREFIX = "ended in the engine";
+/**
+ * One record's console output, ready to print under its `functionLogLine`.
+ *
+ * A header is emitted whenever the label CHANGES, so two lines from one body
+ * sit under one header and a body re-entered after another step gets its own.
+ * A `thrown` entry — the wrapper's own record of a body that failed — takes a
+ * `!` in the gutter rather than an extra column, so the columns stay aligned.
+ *
+ * A record with NO lines whose attempt ended in the engine says so instead of
+ * printing nothing (#3564, {@link ENGINE_END_PREFIX}). The derivation is by
+ * the record's own `endedIn`, which the platform derived from its stored code
+ * — never by re-reading its message here, so a record written before this
+ * child renders exactly as it rendered then (edge 32).
+ */
+export declare function renderInvocationLines(record: any): string[];
+/** What `logs --run` was able to read before it renders anything. */
+export interface RunLogsInput {
+    /** The filtered page, NEWEST first, as the listing route answers it. */
+    records: any[];
+    /** The run's step rows, or null when the read failed. */
+    trace: any[] | null;
+    /** The trace read's failure, if it had one. */
+    traceError?: string | null;
+}
+/**
+ * The whole of `logs --run`'s human output — #3453 (D3453-005).
+ *
+ * Returned rather than printed so every one of its rules is decidable without
+ * a server (#3187's lesson): which runs get a table, what a failed trace read
+ * costs, and the order the records come out in. The command does the two I/O
+ * reads and prints what comes back.
+ *
+ * Records are reversed because the listing answers newest first and a run is
+ * read forwards — an operator following what happened wants the first
+ * invocation at the top.
+ */
+export declare function renderRunLogs(input: RunLogsInput): {
+    lines: string[];
+    warning: string | null;
+};

package/dist/src/lib/function-log-lines.js

@@ -0,0 +1,160 @@
+/**
+ * One invocation's captured console output, in the order it was printed —
+ * #3453 (D3453-005).
+ *
+ * `primitive functions logs --run <run-id>` used to print the same one-row-per
+ * record table the listing prints, so the LINES — the thing an operator opened
+ * the logs for — were only reachable through `--json`. This renders them, under
+ * the step that wrote them.
+ *
+ * Pure, and separate from the command, for the reason `function-log-row.ts`
+ * gives: a rendering rule that lives inside an action can only be tested by
+ * spawning the CLI, and this one has enough cases (two orderings, a header that
+ * changes, a throw, a pre-change record) that spawning for each would be the
+ * wrong trade.
+ */
+import { functionLogLine } from "./function-log-row.js";
+import { renderStepRunTable } from "./step-run-table.js";
+/** The marker a truncated record ends with, so loss is never silent. */
+export const TRUNCATION_MARKER = "… truncated: the platform's per-record cap dropped later lines";
+/**
+ * What an EMPTY record whose attempt ended in the engine says — #3564,
+ * criterion 2 (D3564-007).
+ *
+ * The filing's own complaint: the invocation log held no console output for
+ * these attempts, with `truncated`, `logsUnavailable` and `contentSuppressed`
+ * all unset, so the silence read as "logs lost" when it meant "the handler
+ * printed nothing before the engine took the isolate away". This renderer
+ * printed nothing at all for such a record, which is the reading the filing
+ * asks to be able to make.
+ *
+ * Two facts, never collapsed into one: the first half says the attempt ended
+ * in the engine, and the SECOND half is chosen by the drain's own flags. A
+ * drain that failed — which `DrainedLogs.unavailable` names isolate eviction
+ * as a cause of — is reported as unavailable rather than as an empty handler,
+ * because those are opposite statements and this is precisely the case where
+ * guessing would be wrong.
+ */
+export const ENGINE_END_PREFIX = "ended in the engine";
+function engineEndLine(record) {
+    const why = record?.logsUnavailable === true
+        ? "logs unavailable"
+        : record?.contentSuppressed === true
+            ? "output suppressed"
+            : "no handler output";
+    return `${ENGINE_END_PREFIX} — ${why}`;
+}
+const INDENT = "  ";
+/**
+ * Put one record's two arrays back into CAPTURE order.
+ *
+ * The writer persists `stdout` and `stderr` as two arrays filtered by stream
+ * and `t` is a millisecond offset, so `console.error("first")` followed by
+ * `console.log("second")` in the same millisecond has no surviving order in
+ * the record itself: merging by `t` prints them backwards. `n` is stamped at
+ * capture, in one buffer, and is what restores it.
+ *
+ * A record written before #3453 carries no `n` at all, and one entry having it
+ * while another does not is not a state any writer produces — so the fallback
+ * is chosen for the WHOLE record rather than per entry. Interleaving two
+ * orders would put entries in an order neither of them claims.
+ *
+ * The `t` fallback sorts stably with stdout first on a tie, which is the order
+ * the two arrays already sit in.
+ */
+function inCaptureOrder(record) {
+    const stdout = Array.isArray(record?.stdout) ? record.stdout : [];
+    const stderr = Array.isArray(record?.stderr) ? record.stderr : [];
+    const merged = [...stdout, ...stderr];
+    const everyEntryNumbered = merged.length > 0 && merged.every((entry) => Number.isFinite(entry?.n));
+    const key = everyEntryNumbered
+        ? (entry) => Number(entry.n)
+        : (entry) => Number(entry.t ?? 0);
+    // `Array.prototype.sort` is stable, so equal keys keep the order above —
+    // stdout before stderr.
+    return merged.slice().sort((a, b) => key(a) - key(b));
+}
+/** `step <name> #<occurrence> attempt <n>`, or null between steps. */
+function headerFor(entry) {
+    if (!entry?.step || typeof entry.step.name !== "string")
+        return null;
+    return `step ${entry.step.name} #${entry.step.occurrence ?? 0} attempt ${entry.attempt ?? 1}`;
+}
+/**
+ * One record's console output, ready to print under its `functionLogLine`.
+ *
+ * A header is emitted whenever the label CHANGES, so two lines from one body
+ * sit under one header and a body re-entered after another step gets its own.
+ * A `thrown` entry — the wrapper's own record of a body that failed — takes a
+ * `!` in the gutter rather than an extra column, so the columns stay aligned.
+ *
+ * A record with NO lines whose attempt ended in the engine says so instead of
+ * printing nothing (#3564, {@link ENGINE_END_PREFIX}). The derivation is by
+ * the record's own `endedIn`, which the platform derived from its stored code
+ * — never by re-reading its message here, so a record written before this
+ * child renders exactly as it rendered then (edge 32).
+ */
+export function renderInvocationLines(record) {
+    const out = [];
+    let currentHeader = null;
+    let headerEmitted = false;
+    const entries = inCaptureOrder(record);
+    for (const entry of entries) {
+        const header = headerFor(entry);
+        if (header !== currentHeader) {
+            currentHeader = header;
+            headerEmitted = false;
+        }
+        if (header && !headerEmitted) {
+            out.push(`${INDENT}${header}`);
+            headerEmitted = true;
+        }
+        const indent = header ? INDENT.repeat(2) : INDENT;
+        const gutter = entry?.thrown === true ? `${indent.slice(0, -2)}! ` : indent;
+        const stream = entry?.s === "err" ? "err" : "out";
+        out.push(`${gutter}+${Number(entry?.t ?? 0)}ms  ${stream}  ${String(entry?.line ?? "")}`);
+    }
+    // #3564 — the empty record, explained. Only when the record really has no
+    // lines: one that printed something says more than the sentence does, and a
+    // reader who can see the output does not need to be told there is some.
+    if (entries.length === 0 && record?.endedIn === "engine") {
+        out.push(`${INDENT}${engineEndLine(record)}`);
+    }
+    // Said out loud, because the alternative is output that looks complete after
+    // the cap dropped the later lines or the throw entry. The record persists the
+    // boolean and not the count (F-3453-009), so the marker cannot name one.
+    if (record?.truncated === true)
+        out.push(`${INDENT}${TRUNCATION_MARKER}`);
+    return out;
+}
+/**
+ * The whole of `logs --run`'s human output — #3453 (D3453-005).
+ *
+ * Returned rather than printed so every one of its rules is decidable without
+ * a server (#3187's lesson): which runs get a table, what a failed trace read
+ * costs, and the order the records come out in. The command does the two I/O
+ * reads and prints what comes back.
+ *
+ * Records are reversed because the listing answers newest first and a run is
+ * read forwards — an operator following what happened wants the first
+ * invocation at the top.
+ */
+export function renderRunLogs(input) {
+    const lines = [];
+    // A trace this reader could not fetch is not a reason to withhold the
+    // output: the lines say more than the failure does.
+    const warning = input.traceError
+        ? `Could not read the step trace: ${input.traceError}`
+        : null;
+    // A request invocation has no step rows at all, and an empty table would
+    // say there were steps and none ran.
+    if (input.trace && input.trace.length > 0) {
+        lines.push(renderStepRunTable(input.trace), "");
+    }
+    for (const record of [...(input.records ?? [])].reverse()) {
+        lines.push(functionLogLine(record));
+        lines.push(...renderInvocationLines(record));
+    }
+    return { lines, warning };
+}
+//# sourceMappingURL=function-log-lines.js.map

package/dist/src/lib/function-log-lines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-log-lines.js","sourceRoot":"","sources":["../../../src/lib/function-log-lines.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/function-log-row.d.ts

@@ -0,0 +1,29 @@
+/**
+ * One invocation, as a human reads it — the columns and the tail line.
+ *
+ * Extracted from `commands/functions.ts` by #3462 so the VERSION it added has
+ * somewhere to be tested. The one-shot table, the `--invocation` point read and
+ * the `--follow` tail all render the same facts in the same order, and three
+ * copies of that order in one command file is three chances for them to drift;
+ * a tail line that dropped a column would be a difference nobody could see
+ * without two terminals.
+ */
+/** The columns the one-shot and `--invocation` tables share, in order. */
+export declare const FUNCTION_LOG_COLUMNS: readonly ["TIME", "STATUS", "TRIGGER", "RUNTIME", "VERSION", "RUN/INVOCATION ID", "CODE", "ERROR"];
+/**
+ * The FIRST error line only — #3287.
+ *
+ * A stack is eight kilobytes and a table row is one line, so the row says what
+ * happened and `--json` carries the rest.
+ */
+export declare function firstErrorLine(row: any): string;
+/** The cells one record contributes to a table row. */
+export declare function functionLogCells(row: any): Record<string, string>;
+/**
+ * The same record as one line, for `--follow`.
+ *
+ * Same facts in the same order as the table's columns, so a reader who switches
+ * between them is reading the same thing. An absent value contributes nothing
+ * rather than an empty gap, because a tail line has no columns to keep aligned.
+ */
+export declare function functionLogLine(row: any): string;

package/dist/src/lib/function-log-row.js

@@ -0,0 +1,73 @@
+/**
+ * One invocation, as a human reads it — the columns and the tail line.
+ *
+ * Extracted from `commands/functions.ts` by #3462 so the VERSION it added has
+ * somewhere to be tested. The one-shot table, the `--invocation` point read and
+ * the `--follow` tail all render the same facts in the same order, and three
+ * copies of that order in one command file is three chances for them to drift;
+ * a tail line that dropped a column would be a difference nobody could see
+ * without two terminals.
+ */
+/** The columns the one-shot and `--invocation` tables share, in order. */
+export const FUNCTION_LOG_COLUMNS = [
+    "TIME",
+    "STATUS",
+    "TRIGGER",
+    // #3482 — which RUNTIME the platform ran this invocation under, beside the
+    // DOOR that fired it. `ctx.trigger.kind` says which door; this says whether
+    // the platform ran the code inside the request or as a task run, which is
+    // what `assertRuntime` tests for and what the two budgets differ by. Blank
+    // for a record written before the column existed.
+    "RUNTIME",
+    // #3462 — WHICH version this invocation executed. The record has carried
+    // `configId` since #3287 and nothing rendered it.
+    "VERSION",
+    "RUN/INVOCATION ID",
+    "CODE",
+    "ERROR",
+];
+/**
+ * The FIRST error line only — #3287.
+ *
+ * A stack is eight kilobytes and a table row is one line, so the row says what
+ * happened and `--json` carries the rest.
+ */
+export function firstErrorLine(row) {
+    const message = String(row?.errorMessage ?? "").trim();
+    if (message)
+        return message.split("\n")[0];
+    const stderr = Array.isArray(row?.stderr) ? row.stderr : [];
+    return stderr.length > 0 ? String(stderr[0].line ?? "") : "";
+}
+/** The cells one record contributes to a table row. */
+export function functionLogCells(row) {
+    return {
+        startedAt: row?.startedAt ?? "",
+        status: row?.status ?? "",
+        trigger: row?.trigger?.kind ?? "",
+        runtime: row?.runtime ?? "",
+        configId: row?.configId ?? "",
+        // A trigger fire and a task run name their run; a request invocation's key
+        // is its own id.
+        runOrInvocation: row?.runId || row?.invocationId || "",
+        errorCode: row?.errorCode ?? "",
+        firstError: firstErrorLine(row),
+    };
+}
+/**
+ * The same record as one line, for `--follow`.
+ *
+ * Same facts in the same order as the table's columns, so a reader who switches
+ * between them is reading the same thing. An absent value contributes nothing
+ * rather than an empty gap, because a tail line has no columns to keep aligned.
+ */
+export function functionLogLine(row) {
+    const cells = functionLogCells(row);
+    const runtime = cells.runtime ? `  ${cells.runtime}` : "";
+    const version = cells.configId ? `  ${cells.configId}` : "";
+    const code = cells.errorCode ? `  ${cells.errorCode}` : "";
+    const detail = cells.firstError ? `  ${cells.firstError}` : "";
+    return (`${cells.startedAt}  ${cells.status}  ${cells.trigger}${runtime}${version}  ` +
+        `${cells.runOrInvocation}${code}${detail}`);
+}
+//# sourceMappingURL=function-log-row.js.map

package/dist/src/lib/function-log-row.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-log-row.js","sourceRoot":"","sources":["../../../src/lib/function-log-row.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,0EAA0E;AAC1E,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,MAAM;IACN,QAAQ;IACR,SAAS;IACT,2EAA2E;IAC3E,4EAA4E;IAC5E,0EAA0E;IAC1E,2EAA2E;IAC3E,kDAAkD;IAClD,SAAS;IACT,yEAAyE;IACzE,kDAAkD;IAClD,SAAS;IACT,mBAAmB;IACnB,MAAM;IACN,OAAO;CACC,CAAC;AAEX;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,GAAQ;IACrC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,EAAE,YAAY,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IACvD,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IAC5D,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAC/D,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,gBAAgB,CAAC,GAAQ;IACvC,OAAO;QACL,SAAS,EAAE,GAAG,EAAE,SAAS,IAAI,EAAE;QAC/B,MAAM,EAAE,GAAG,EAAE,MAAM,IAAI,EAAE;QACzB,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,IAAI,EAAE;QACjC,OAAO,EAAE,GAAG,EAAE,OAAO,IAAI,EAAE;QAC3B,QAAQ,EAAE,GAAG,EAAE,QAAQ,IAAI,EAAE;QAC7B,2EAA2E;QAC3E,iBAAiB;QACjB,eAAe,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,YAAY,IAAI,EAAE;QACtD,SAAS,EAAE,GAAG,EAAE,SAAS,IAAI,EAAE;QAC/B,UAAU,EAAE,cAAc,CAAC,GAAG,CAAC;KAChC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,GAAQ;IACtC,MAAM,KAAK,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACpC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1D,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC5D,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3D,MAAM,MAAM,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/D,OAAO,CACL,GAAG,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,IAAI;QAC7E,GAAG,KAAK,CAAC,eAAe,GAAG,IAAI,GAAG,MAAM,EAAE,CAC3C,CAAC;AACJ,CAAC"}

package/dist/src/lib/function-run.d.ts

@@ -59,42 +59,61 @@ export type IdentityPlan = {
  * that had already run.
  */
 export declare function resolveRunFlags(flags: RunFlags): FlagResolution;
+/** The two runtimes the platform runs a function under (#3482). */
+export type FunctionRuntime = "request" | "task";
 /**
- * The three words a VERSION's mode may be (#3281, widened by #3454) and the
- * two a CALL may name. Spelled here rather than imported so this module stays
- * the thin decision layer the CLI's verbs read; the vendored grammar in
- * `generated-config-surfaces.ts` is where the words are defined.
+ * The runtime a function run used, read from the run row — #3482, C-6.
+ *
+ * `WorkflowRun.executionMode` is the runtime under the old word, and #3482
+ * does not rename a stored column (D3482-009; phase 7 owns the rename), so the
+ * mapping lives here, once, and every surface that says "runtime" says it the
+ * same way. `sync` is the request runtime — a webhook delivery, a
+ * `workflow.call` leaf — and `durable` is the task runtime.
+ *
+ * ABSENT means the task runtime, not "unknown": every writer of a durable row
+ * has written `durable` since #3186, and the rows that predate the column are
+ * durable runs. A row that says something else entirely is not a runtime this
+ * platform has, and answering null is how a reader learns that rather than
+ * being told a word that was never true.
  */
-export type FunctionMode = "request" | "task" | "any";
-export type FunctionRunner = "request" | "task";
-export type ModePrecheck = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-    errorCode: "FUNCTION_MODE_MISMATCH";
-};
+export declare function runtimeForExecutionMode(executionMode: unknown): FunctionRuntime | null;
 /**
- * Refuse the wrong verb before any request — D3448-008.
- *
- * A COURTESY that saves a round trip, and it says so: the authoritative
- * refusal is the server's `mode` precondition, which the CLI always sends, so
- * a version repointed between this read and the call is refused by the server
- * with nothing executed (D3448-SO-002).
+ * The RUNTIME cell of one `functions runs` row.
  *
- * A function with NO pushed version is not pre-judged: it has no mode to
- * disagree with, and the server's `FUNCTION_NOT_PUSHED` is the honest answer
- * (edge 30).
+ * Blank rather than guessed for a row this reader cannot place: `runs` pages
+ * one function's own runs, but the same shape reaches the CLI from surfaces
+ * that carry DSL rows too, and printing `task` for one would be a word about
+ * something that has no runtime at all.
  */
-export declare function precheckMode(verb: RunVerb, activeMode: FunctionMode | null | undefined, functionKey: string): ModePrecheck;
+export declare function runRuntimeCell(run: {
+    executionMode?: unknown;
+} | null | undefined): string;
 /**
- * The RUNNER a verb states on the wire.
+ * The two slice cells of one `functions runs` row — REFRESHES and RESETS.
+ *
+ * One rule for both, because they are two facts about the same record and the
+ * distinction that matters is the same for each: a row with NO slice record
+ * gets a BLANK cell, and a record that carries no count gets `0`.
  *
- * A verb always names one of the two: `any` is a mode a version may have, and
- * saying it here would be asking the server to pick, which #3454 refuses at
- * the boundary by name.
+ *   - blank means "there is no record" — a request invocation opens no lease,
+ *     and neither did any run that predates the record's own child;
+ *   - `0` means "the record says nothing happened", which for #3566 is the
+ *     answer an operator needs: a fabricated zero on a row with no record would
+ *     read as "the platform never reset this run", and the row cannot know that.
+ *
+ * A value that is not a whole number reads `0` rather than reaching the table:
+ * the cell is a count, and printing `NaN` or `two` in a column of numbers
+ * teaches an operator nothing.
  */
-export declare function modeFor(verb: RunVerb): FunctionRunner;
+export declare function runSliceCells(run: {
+    slice?: {
+        refreshCount?: unknown;
+        resets?: unknown;
+    } | null;
+} | null | undefined): {
+    refreshes: string;
+    resets: string;
+};
 /** The JS client's schedule: 400 ms doubling to a 5 s ceiling. */
 export declare const WAIT_INITIAL_DELAY_MS = 400;
 export declare const WAIT_MAX_DELAY_MS = 5000;
@@ -259,13 +278,12 @@ export interface RefusalLines {
 /**
  * Turn a refusal envelope into the lines an operator reads — #3448 D3448-010.
  *
- * Pure, because it carries the two facts that make handing the envelope back
- * worth anything instead of throwing: a 429's `Retry-After`, and the VERSION'S
- * REAL MODE on a 409 mode mismatch. Both are things the server already worked
- * out, and both would be re-derived badly from an exception message.
+ * Pure, because it carries the fact that makes handing the envelope back
+ * worth anything instead of throwing: a 429's `Retry-After`, which the server
+ * already worked out and which would be re-derived badly from an exception
+ * message.
  *
- * The mode line is also the CLI half of edge 31: the pre-check is a courtesy,
- * and a version repointed between it and the call is refused by the SERVER —
- * so what an operator sees in that race is this.
+ * #3482 — there is no "Version mode" line any more. It named the mode a
+ * refused call's version was locked to, and no version is locked to anything.
  */
 export declare function refusalLines(answer: RefusalAnswer): RefusalLines;

package/dist/src/lib/function-run.js

@@ -75,46 +75,62 @@ export function resolveRunFlags(flags) {
     return { ok: true, input, identity, timeoutSeconds };
 }
 /**
- * Refuse the wrong verb before any request — D3448-008.
+ * The runtime a function run used, read from the run row — #3482, C-6.
  *
- * A COURTESY that saves a round trip, and it says so: the authoritative
- * refusal is the server's `mode` precondition, which the CLI always sends, so
- * a version repointed between this read and the call is refused by the server
- * with nothing executed (D3448-SO-002).
+ * `WorkflowRun.executionMode` is the runtime under the old word, and #3482
+ * does not rename a stored column (D3482-009; phase 7 owns the rename), so the
+ * mapping lives here, once, and every surface that says "runtime" says it the
+ * same way. `sync` is the request runtime — a webhook delivery, a
+ * `workflow.call` leaf — and `durable` is the task runtime.
  *
- * A function with NO pushed version is not pre-judged: it has no mode to
- * disagree with, and the server's `FUNCTION_NOT_PUSHED` is the honest answer
- * (edge 30).
+ * ABSENT means the task runtime, not "unknown": every writer of a durable row
+ * has written `durable` since #3186, and the rows that predate the column are
+ * durable runs. A row that says something else entirely is not a runtime this
+ * platform has, and answering null is how a reader learns that rather than
+ * being told a word that was never true.
  */
-export function precheckMode(verb, activeMode, functionKey) {
-    if (!activeMode)
-        return { ok: true };
-    // #3454 — an `any` function takes either runner, so neither verb is the
-    // wrong one and there is no other door to refuse at. The pre-check is a
-    // courtesy that saves a round trip on a LOCK; the server is the authority.
-    if (activeMode === "any")
-        return { ok: true };
-    const wanted = modeFor(verb);
-    if (activeMode === wanted)
-        return { ok: true };
-    const other = activeMode === "task" ? "start" : "invoke";
-    return {
-        ok: false,
-        errorCode: "FUNCTION_MODE_MISMATCH",
-        error: `Function '${functionKey}' is a ${activeMode} function: ` +
-            `'functions ${verb}' runs the ${wanted} runner. ` +
-            `Use 'primitive functions ${other} ${functionKey}'.`,
-    };
+export function runtimeForExecutionMode(executionMode) {
+    if (executionMode === "sync")
+        return "request";
+    if (executionMode === "durable" || executionMode === undefined || executionMode === null) {
+        return "task";
+    }
+    return null;
+}
+/**
+ * The RUNTIME cell of one `functions runs` row.
+ *
+ * Blank rather than guessed for a row this reader cannot place: `runs` pages
+ * one function's own runs, but the same shape reaches the CLI from surfaces
+ * that carry DSL rows too, and printing `task` for one would be a word about
+ * something that has no runtime at all.
+ */
+export function runRuntimeCell(run) {
+    return runtimeForExecutionMode(run?.executionMode) ?? "";
 }
 /**
- * The RUNNER a verb states on the wire.
+ * The two slice cells of one `functions runs` row — REFRESHES and RESETS.
+ *
+ * One rule for both, because they are two facts about the same record and the
+ * distinction that matters is the same for each: a row with NO slice record
+ * gets a BLANK cell, and a record that carries no count gets `0`.
+ *
+ *   - blank means "there is no record" — a request invocation opens no lease,
+ *     and neither did any run that predates the record's own child;
+ *   - `0` means "the record says nothing happened", which for #3566 is the
+ *     answer an operator needs: a fabricated zero on a row with no record would
+ *     read as "the platform never reset this run", and the row cannot know that.
  *
- * A verb always names one of the two: `any` is a mode a version may have, and
- * saying it here would be asking the server to pick, which #3454 refuses at
- * the boundary by name.
+ * A value that is not a whole number reads `0` rather than reaching the table:
+ * the cell is a count, and printing `NaN` or `two` in a column of numbers
+ * teaches an operator nothing.
  */
-export function modeFor(verb) {
-    return verb === "start" ? "task" : "request";
+export function runSliceCells(run) {
+    const slice = run?.slice;
+    if (!slice || typeof slice !== "object")
+        return { refreshes: "", resets: "" };
+    const count = (value) => String(Number.isInteger(Number(value)) ? Number(value) : 0);
+    return { refreshes: count(slice.refreshCount), resets: count(slice.resets) };
 }
 // ─── waiting ────────────────────────────────────────────────────────
 /** The JS client's schedule: 400 ms doubling to a 5 s ceiling. */
@@ -347,14 +363,13 @@ export async function withMintedToken(effects, use) {
 /**
  * Turn a refusal envelope into the lines an operator reads — #3448 D3448-010.
  *
- * Pure, because it carries the two facts that make handing the envelope back
- * worth anything instead of throwing: a 429's `Retry-After`, and the VERSION'S
- * REAL MODE on a 409 mode mismatch. Both are things the server already worked
- * out, and both would be re-derived badly from an exception message.
+ * Pure, because it carries the fact that makes handing the envelope back
+ * worth anything instead of throwing: a 429's `Retry-After`, which the server
+ * already worked out and which would be re-derived badly from an exception
+ * message.
  *
- * The mode line is also the CLI half of edge 31: the pre-check is a courtesy,
- * and a version repointed between it and the call is refused by the SERVER —
- * so what an operator sees in that race is this.
+ * #3482 — there is no "Version mode" line any more. It named the mode a
+ * refused call's version was locked to, and no version is locked to anything.
  */
 export function refusalLines(answer) {
     const body = answer.body ?? {};
@@ -362,10 +377,6 @@ export function refusalLines(answer) {
     const fields = [];
     if (body.errorCode)
         fields.push({ label: "Code", value: String(body.errorCode) });
-    // The version's own mode, so a caller learns what the code is registered for
-    // rather than only that they asked for the wrong thing.
-    if (body.mode)
-        fields.push({ label: "Version mode", value: String(body.mode) });
     const details = Array.isArray(body.details)
         ? body.details.map((detail) => typeof detail === "string" ? detail : JSON.stringify(detail))
         : [];