@jini-ai/chat 0.5.4 → 0.5.6

package/dist/core/question-form/format.js

@@ -1,3 +1,14 @@
+/**
+ * @module question-form/format
+ *
+ * Answer presentation: turning a submitted answer set into the prose the
+ * agent reads on its next turn, plus the label/value lookups also used by
+ * `normalize.ts`'s default-value resolution. Split out of the original
+ * single-file `question-form.ts`; see `../question-form.ts` for the public
+ * facade.
+ */
+import { redactQuestionAnswers, isSecretQuestion } from './secret-answers.js';
+import { CREDENTIAL_CARD_GUIDANCE, redactUserText } from '../user-text-redaction.js';
 /**
  * Format a finished set of answers into a prose user message the agent can
  * read on its next turn. The shape is stable enough that the agent can
@@ -6,10 +17,11 @@
  * @complexity O(q) in the number of questions on the form.
  */
 export function formatFormAnswers({ form, answers }) {
+    const safe = redactQuestionAnswers({ form, answers });
     const lines = [];
     lines.push(`[form answers — ${form.id}]`);
     for (const q of form.questions) {
-        const v = answers[q.id];
+        const v = safe.answers[q.id];
         let display;
         if (Array.isArray(v)) {
             display = v.length > 0 ? v.map((value) => formOptionDisplayForValue(q, value)).join(', ') : '(skipped)';
@@ -22,7 +34,9 @@ export function formatFormAnswers({ form, answers }) {
         }
         lines.push(`- ${q.label}: ${display}`);
     }
-    return lines.join('\n');
+    if (safe.secretRedacted || form.questions.some(question => isSecretQuestion({ question })))
+        lines.push(CREDENTIAL_CARD_GUIDANCE);
+    return redactUserText({ text: lines.join('\n') }).text;
 }
 function formOptionDisplayForValue(question, value) {
     const match = question.options?.find((option) => option.value === value || option.label === value);

package/dist/core/question-form/normalize.js

@@ -25,6 +25,7 @@ export function mapRawQuestion({ q, index }) {
     const accept = typeof qo.accept === 'string' ? qo.accept : undefined;
     return {
         id,
+        ...(typeof qo.name === 'string' ? { name: qo.name } : {}),
         label,
         type,
         ...(options ? { options } : {}),

package/dist/core/question-form/secret-answers.d.ts

@@ -0,0 +1,38 @@
+/** Chat question forms are model-visible text, never secure credential storage. */
+import { type UserTextRedactionOptions } from '../user-text-redaction.js';
+import type { FormQuestion, QuestionForm } from './types.js';
+export declare function isSecretQuestion({ question }: {
+    readonly question: Pick<FormQuestion, 'id' | 'label' | 'type' | 'name'>;
+}): boolean;
+/** The map as well as its formatted transcript must be safe: hosts often persist both. */
+export declare function redactQuestionAnswers({ form, answers }: {
+    readonly form: QuestionForm;
+    readonly answers: Readonly<Record<string, string | string[]>>;
+}, options?: UserTextRedactionOptions): {
+    readonly answers: Record<string, string | string[]>;
+    readonly secretRedacted: boolean;
+    readonly count: number;
+};
+/** Never populate a credential text question from model-supplied defaults. */
+export declare function withoutSecretQuestionDefaults({ form }: {
+    readonly form: QuestionForm;
+}): QuestionForm;
+/** Attributes are presentation policy, shared by any host renderer. */
+export declare function questionTextInputProps({ question }: {
+    readonly question: FormQuestion;
+}): {
+    type: 'password' | 'text';
+    autoComplete?: string;
+    spellCheck?: boolean;
+};
+export declare function questionTextareaProps({ question }: {
+    readonly question: FormQuestion;
+}): {
+    autoComplete?: string;
+    spellCheck?: boolean;
+    style?: {
+        WebkitTextSecurity: string;
+        whiteSpace: 'pre-wrap';
+    };
+};
+//# sourceMappingURL=secret-answers.d.ts.map

package/dist/core/question-form/secret-answers.js

@@ -0,0 +1,45 @@
+/** Chat question forms are model-visible text, never secure credential storage. */
+import { redactUserText } from '../user-text-redaction.js';
+export function isSecretQuestion({ question }) {
+    if (question.type !== 'text' && question.type !== 'textarea')
+        return false;
+    const names = [question.id, question.label, question.name ?? ''].join(' ').replace(/([a-z])([A-Z])/g, '$1 $2');
+    return /(?:^|[^a-z0-9])(?:key|token|password|passwd|secret)(?:$|[^a-z0-9])/i.test(names);
+}
+/** The map as well as its formatted transcript must be safe: hosts often persist both. */
+export function redactQuestionAnswers({ form, answers }, options = {}) {
+    let count = 0;
+    const cleaned = {};
+    const redact = options.redactUserText ?? redactUserText;
+    for (const question of form.questions) {
+        const value = answers[question.id];
+        if (value === undefined)
+            continue;
+        const guard = (text) => {
+            const result = redact({ text }, { secretField: isSecretQuestion({ question }) });
+            count += result.count;
+            return result.text;
+        };
+        cleaned[question.id] = Array.isArray(value) ? value.map(guard) : guard(value);
+    }
+    if (count > 0)
+        options.onSecretRedacted?.({ secretRedacted: true, count });
+    return { answers: cleaned, secretRedacted: count > 0, count };
+}
+/** Never populate a credential text question from model-supplied defaults. */
+export function withoutSecretQuestionDefaults({ form }) {
+    return { ...form, questions: form.questions.map(question => {
+            if (!isSecretQuestion({ question }))
+                return question;
+            const { defaultValue: _defaultValue, ...safe } = question;
+            return safe;
+        }) };
+}
+/** Attributes are presentation policy, shared by any host renderer. */
+export function questionTextInputProps({ question }) {
+    return isSecretQuestion({ question }) ? { type: 'password', autoComplete: 'new-password', spellCheck: false } : { type: 'text' };
+}
+export function questionTextareaProps({ question }) {
+    return isSecretQuestion({ question }) ? { autoComplete: 'off', spellCheck: false, style: { WebkitTextSecurity: 'disc', whiteSpace: 'pre-wrap' } } : {};
+}
+//# sourceMappingURL=secret-answers.js.map

package/dist/core/question-form/types.d.ts

@@ -37,6 +37,8 @@ export interface FormOption {
     description?: string;
 }
 export interface FormQuestion {
+    /** Optional model-supplied field name, retained for credential masking policy. */
+    name?: string;
     id: string;
     label: string;
     type: QuestionType;

package/dist/core/question-form.d.ts

@@ -36,4 +36,5 @@ export type { QuestionType, DirectionCard, FormOption, FormQuestion, QuestionFor
 export { splitOnQuestionForms, findFirstQuestionForm, parseQuestionForm, stripTrailingOpenQuestionForm, hasUnterminatedQuestionForm, parsePartialQuestionForm, } from './question-form/scan.js';
 export { isRenderableColor } from './question-form/normalize.js';
 export { formatFormAnswers, formOptionLabelForValue, formOptionValueForLabel } from './question-form/format.js';
+export { isSecretQuestion, redactQuestionAnswers, withoutSecretQuestionDefaults, questionTextInputProps, questionTextareaProps } from './question-form/secret-answers.js';
 //# sourceMappingURL=question-form.d.ts.map

package/dist/core/question-form.js

@@ -1,4 +1,5 @@
 export { splitOnQuestionForms, findFirstQuestionForm, parseQuestionForm, stripTrailingOpenQuestionForm, hasUnterminatedQuestionForm, parsePartialQuestionForm, } from './question-form/scan.js';
 export { isRenderableColor } from './question-form/normalize.js';
 export { formatFormAnswers, formOptionLabelForValue, formOptionValueForLabel } from './question-form/format.js';
+export { isSecretQuestion, redactQuestionAnswers, withoutSecretQuestionDefaults, questionTextInputProps, questionTextareaProps } from './question-form/secret-answers.js';
 //# sourceMappingURL=question-form.js.map

package/dist/core/run-events/entry.d.ts

@@ -4,6 +4,30 @@
  * event names and excluded run-ID prefixes are explicit host inputs, never product wire defaults.
  * Authenticated routing, ownership, boot repair and storage transactions remain host responsibilities. */
 import type { AgentEvent } from "../events.js";
+/**
+ * @file The ONE translation from an agent-daemon run stream to chat events, shared by the browser
+ * and the server.
+ *
+ * Purpose:
+ * A daemon run streams `@jini-ai/protocol` frames (`agent`/`stdout`/`stderr`/`error`/`end`). A saved
+ * chat row stores chat-core `AgentEvent`s plus a text `content` and a `run_status`. Until 2026-09-27
+ * the frame-to-event translation lived only in the admin SPA (`apps/admin/src/lib/assistant-transport.ts`),
+ * so only a connected browser could turn a run into a saved answer: close the tab, or lose it to a
+ * restart, and the row stayed `running` with no content forever (FINDING A,
+ * `ADS-memory/reports/2026-09-27-stuck-chat-root-cause.md`).
+ *
+ * The server-side finalizer (`server/runtime/composition/modules/assistant-run-finalizer.ts`) now
+ * saves the finished turn itself, and it must write exactly what the browser would have written. Two
+ * copies of this switch would drift, so both import this file through the shared
+ * `@jini-ai/chat/core/run-events` entry, with the host's bundler, test runner and TypeScript
+ * resolving the same package contract.
+ *
+ * Architectural role:
+ * PURE. No I/O, no DOM, no Node built-ins. The one value import is `@jini-ai/chat/core`'s content
+ * rule, itself pure and React-free, so the saved `content` and the browser's can never differ.
+ * `ReadableStream`/`TextDecoder` in {@link readSseFrames} are globals in both runtimes. Keep it that
+ * way — the admin bundle imports it.
+ */
 import type { ChatRunStatus } from "../messages.js";
 export interface RunAgentPayload {
     readonly type: string;
@@ -17,15 +41,53 @@ export interface RunProtocolEventWire {
 /** Display a wire scalar or JSON value using the existing empty-null convention. */
 export declare function asString({ value }: {
     value: unknown;
-}): string;
+}, _options?: Record<string, never>): string;
+/**
+ * Parses a `"usage"` wire payload into its renderable `AgentEvent`.
+ *
+ * The one case in {@link translateRunAgentPayload}'s switch with real branching: four independent
+ * optional fields, each `typeof`-checked before use (a malformed/missing field must not throw or
+ * silently coerce to `0`/`NaN`). Pulled out (2026-08-06, complexity pass, sixth pass) so those four
+ * ternaries are scored in their own scope instead of the switch's — this is the fix for the earlier
+ * `@complexityExemption`'s cognitive attribution on `translateRunAgentPayload`, which credited the
+ * `mcp-ui`/`a2ui` cases (each a one-line unwrap, zero branching — see their own comments below) for
+ * a cost that actually came from here.
+ */
 /** Keep only numeric usage fields; omit absent fields without changing JSON output. */
 export declare function parseUsageEvent({ payload }: {
     payload: RunAgentPayload;
-}): AgentEvent;
+}, _options?: Record<string, never>): AgentEvent;
+/**
+ * Reduces one wire-level `RunAgentPayload` into zero or one renderable `AgentEvent`s.
+ *
+ * Exported (a pure function, so directly testable with no `EventSource`/`fetch` stub needed — see
+ * `assistant-transport.transcript.test.ts`'s own module doc for the same reasoning applied to
+ * `runPrompt`) so `assistant-transport.a2ui.test.ts` can assert the `"a2ui"` branch below in
+ * isolation.
+ *
+ * @complexityExemption (2026-08-06, complexity pass, sixth pass; bar is ≤9/≤9) **Score: 12
+ * cyclomatic / 3 cognitive. Bar: ≤9 cyclomatic AND ≤9 cognitive. Cyclomatic-only exemption —
+ * cognitive already clears the bar since {@link parseUsageEvent} above took the switch's only real
+ * branching out of this function's own scope.** (An earlier version of this comment attributed the
+ * cognitive cost to the `mcp-ui`/`a2ui` cases below; that was wrong — an independent audit measured
+ * that extracting `parseUsageEvent` alone drops cognitive from 11 to 3, which only makes sense if
+ * `usage` was the real source. `mcp-ui`/`a2ui` are one-line unwraps with zero branching, exactly as
+ * their own comments already said.) Cyclomatic stays over by construction, not by accident: this is
+ * a flat `switch` over `RunProtocolEventWire`'s closed `payload.type` vocabulary, one `case` per
+ * wire type, and cyclomatic counts every `case` as a branch regardless of shape. Tried and rejected:
+ * a `Record<string, (payload) => AgentEvent | null>` lookup table scores lower but loses two things
+ * a switch over a TS discriminated union keeps — exhaustiveness checking (a lookup table compiles
+ * with a missing key; this switch does not, once `payload.type` is narrowed to the real union rather
+ * than the wire's untyped `string`), and the ability to attach a multi-paragraph comment to one case
+ * explaining a specific interop bug (the `mcp-ui`/`a2ui` cases' comments each document why THAT case
+ * cannot fall through to `default` — see below). A lookup table would have to carry those as a
+ * parallel structure, one step removed from the code they explain. Left as a `switch`, documented
+ * here rather than only in this session's report.
+ */
 /** Reduce one daemon payload; preserve UI envelopes and drop duplicate input fragments. */
 export declare function translateRunAgentPayload({ payload }: {
     payload: RunAgentPayload;
-}): AgentEvent | null;
+}, _options?: Record<string, never>): AgentEvent | null;
 /** Host-supplied status messages; no host branding or log path defaults. */
 export interface RunNotices {
     readonly toolStepLimit: Extract<AgentEvent, {
@@ -43,13 +105,32 @@ export interface RunNotices {
         outcome: TerminalOutcome;
     }) => string;
 }
+/**
+ * Turns a terminal stream `reason` into the one renderable event a human needs to see, or `null`
+ * when the reason speaks for itself.
+ *
+ * Only `max_tool_turns` qualifies today, and it qualifies for a specific reason: it is the one
+ * terminal reason that is INDISTINGUISHABLE from success in the pane. `stop`/`end_turn` mean the
+ * assistant finished; an `error` reason already renders as an error. A turn that hit the tool-step
+ * ceiling just stops — mid-task, with whatever partial text it had, and nothing on screen saying
+ * the work was cut short rather than completed. That is the failure this exists to close: the
+ * server now reports the loop's real reason (`byok-provider-turn.ts`'s `normalizeTurnResult`
+ * captures it instead of echoing the provider's last raw stop code), and until this, the browser
+ * received that reason and dropped it.
+ *
+ * Rendered as a `status` event rather than an `error`, deliberately: nothing failed. The turn did
+ * real work and stopped at a budget, and the useful next action is "ask it to continue", which is
+ * what the detail says.
+ */
 /** A host notice for a run that used its tool-step budget. */
 export declare function terminalReasonNotice({ reason, notice }: {
     reason: string;
     notice: Extract<AgentEvent, {
         kind: "status";
     }>;
-}): AgentEvent | null;
+}, _options?: Record<string, never>): AgentEvent | null;
+/** A daemon `end` frame's non-successful terminal classification, as the daemon itself recorded it
+ *  in `@jini-ai/protocol`'s `RunEndPayload`. */
 export interface TerminalOutcome {
     readonly status: "failed" | "canceled";
     readonly code: string;
@@ -59,63 +140,174 @@ export interface TerminalOutcome {
 /** Read non-successful daemon classification without throwing on malformed frames. */
 export declare function readTerminalOutcome({ raw }: {
     raw: string | undefined;
-}): TerminalOutcome | null;
+}, _options?: Record<string, never>): TerminalOutcome | null;
+/**
+ * Turns a daemon `end` frame's terminal outcome into a visible `status` event when — and only when —
+ * the run did NOT succeed.
+ *
+ * WHY THIS EXISTS (2026-09-06 chat-death investigation, `ADS-memory/reports/2026-09-06-chat-death-investigation.md`):
+ * `@jini-ai/protocol`'s `RunEndPayload` carries `status`/`code`/`signal`/`resumable`, and
+ * `@jini-ai/daemon`'s `finish()` is the ONLY event a terminal run emits — there is no separate
+ * `error` frame for a failed run. {@link subscribeToRun}'s `end` listener read only `reason` (a
+ * field `RunEndPayload` does not even have — it is BYOK-only), so a run the daemon had already
+ * classified `failed` arrived here indistinguishable from a completed one, was reported through
+ * `onDone`, and was persisted to `chat.db` as `run_status='succeeded'` with empty content. Two such
+ * rows existed in the investigated host's `chat.db` — one `codex`, one `claude`, 578 ms and 552 ms — and they
+ * are what "the chat just craps out with no error" actually looks like on disk.
+ *
+ * This is the SEEN half of that fix; {@link terminalFailureError} below is the WRITTEN-DOWN half
+ * (2026-09-07, owner-approved). An earlier version of this comment said the persistence change was
+ * deliberately NOT made and was out of scope until the owner signed off — that is no longer true,
+ * and the two halves stayed separate functions only because they disagree on exactly one input:
+ * `canceled` earns a notice but is not a failure.
+ *
+ * Returns `null` for a successful or absent status so a normal turn gains no extra event.
+ */
 /** A visible terminal classification rendered with host-supplied copy. */
 export declare function terminalOutcomeNotice({ raw, notices }: {
     raw: string | undefined;
     notices: RunNotices;
-}): AgentEvent | null;
+}, _options?: Record<string, never>): AgentEvent | null;
+/**
+ * The reportable `Error` for a daemon `end` frame the daemon itself classified as `failed`, or
+ * `null` for every other terminal outcome.
+ *
+ * WHY THIS EXISTS (2026-09-07, owner-approved): it is what makes a dead run RECOVERABLE FROM THE
+ * DATABASE ALONE. Until now a failed run was reported only through `onDone`, so the durable record
+ * said `run_status='succeeded'` with empty content: the live transcript was the ONLY place the
+ * failure was visible, and once it was gone the row was indistinguishable from a successful turn
+ * that happened to answer with nothing. That lie is why diagnosing chat deaths burned multiple
+ * sessions and carried a wrong premise through two handoffs. `f682eff2` deliberately left it in
+ * place ("a behavior change to what the product writes down... out of scope until the owner signs
+ * off"); the owner has now signed off, and this is that change.
+ *
+ * NOTHING IN THIS FILE COMPUTES `runStatus`. Three pieces of `@jini-ai/chat` do, and the whole
+ * effect of this function rests on all three:
+ *   1. `useRunStream`'s `onError` sets the run's status to `'error'` — and its `onDone` is written
+ *      as `prev.status === 'error' ? prev.status : 'done'`, so an `onDone` arriving AFTER this
+ *      preserves the failure instead of overwriting it. That is what lets {@link subscribeToRun}
+ *      report the failure and STILL settle the run through `finish()` with its collected events
+ *      intact, rather than having to choose between the two. The call order in that listener is
+ *      load-bearing, not incidental.
+ *   2. `useConversation` maps run status `'error'` to `ChatMessage.runStatus: 'failed'`.
+ *   3. `isTerminalRunStatus` already counts `'failed'` as terminal, so `assistant-chats.ts`'s
+ *      `persistableMessages` KEEPS the message (it discards only still-streaming turns) and
+ *      `AssistantDock/hooks/AssistantDock.hooks.tsx`'s `shouldPublishOnMessagesChange` still
+ *      settles the dock. A failed run therefore cannot hang the pane waiting for a terminal state
+ *      that never arrives — which is the failure this change would otherwise have traded the wrong
+ *      record for.
+ *
+ * `canceled` is excluded on purpose: a run the operator stopped is not a failure, and
+ * `useRunStream.cancel()` already stamps its own `'canceled'` status. Marking it `failed` would
+ * swap one wrong record for another.
+ *
+ * Historical rows are NOT retrofitted. The investigated host's `chat.db` held 2 such rows on 2026-09-07 and
+ * the pre-split `content.db` copy held 6; nothing distinguishes a genuinely empty
+ * successful answer from a death after the fact, so a migration could only guess. Going-forward
+ * correctness is the goal.
+ */
 /** Report a failed run; operator cancellation is not a failure. */
 export declare function terminalFailureError({ raw }: {
     raw: string | undefined;
-}): Error | null;
+}, _options?: Record<string, never>): Error | null;
+/** Reads a terminal frame's `reason` from either stream shape without letting a malformed or absent
+ *  body prevent the turn from ending: the daemon path wraps it in a `RunProtocolEventWire.payload`,
+ *  the BYOK path sends a bare `{reason}`, and `subscribeToRun`'s `end` event may carry no data at
+ *  all. A notice is a nicety; finishing the run is not. */
 /** Read a wrapped daemon or bare provider terminal reason, failing soft. */
 export declare function readTerminalReason({ raw, wrapped }: {
     raw: string | undefined;
     wrapped: boolean;
-}): string;
+}, _options?: Record<string, never>): string;
+/**
+ * Parses one blank-line-delimited SSE frame's raw text into `{event, data}`, split out as its own
+ * pure function so it is directly testable with a plain string, no `ReadableStream`/reader involved.
+ *
+ * Returns `null` for a frame with no `data:` lines — {@link readSseFrames} skips yielding those
+ * (a bare `event: ping` keepalive, for example, or a frame carrying only an `id:` field).
+ */
 /** Parse the existing named SSE framing; bare keepalive frames return null. */
 export declare function parseFrame({ rawFrame }: {
     rawFrame: string;
-}): {
+}, _options?: Record<string, never>): {
     event: string;
     data: string;
 } | null;
-/** Decode the existing named SSE framing; cancellation always releases its reader. */
+/**
+ * Splits a `text/event-stream` response body into `{event, data}` frames. Frames are
+ * blank-line-delimited per the SSE spec; per-frame field parsing lives in {@link parseFrame} above.
+ *
+ * @complexity O(n) in response body bytes; O(1) additional buffering per chunk beyond the
+ * not-yet-terminated tail of the current frame.
+ * @overallScore 100
+ */
+/** Decode complete named frames; cancellation always releases its reader. Inherits shared framing costs. */
 export declare function readSseFrames({ body }: {
     body: ReadableStream<Uint8Array>;
-}): AsyncGenerator<{
+}, _options?: Record<string, never>): AsyncGenerator<{
     event: string;
     data: string;
 }>;
+/**
+ * Whether the agent daemon holds this run, so its event stream can be read at
+ * `/api/runs/:id/events`. A BYOK or AG-UI run id names a turn that lived on one browser request, and
+ * there is nothing server-side to watch.
+ */
 /** Identify runs held by the daemon using the host's excluded ID prefixes. */
 export declare function isDaemonRunId({ runId, excludedPrefixes }: {
     runId: string;
     excludedPrefixes: readonly string[];
-}): boolean;
+}, _options?: Record<string, never>): boolean;
 /** Copy the host's interruption notice into a saved turn. */
 export declare function runInterruptedNotice({ notice }: {
     notice: Extract<AgentEvent, {
         kind: "status";
     }>;
-}): AgentEvent;
+}, _options?: Record<string, never>): AgentEvent;
+/**
+ * A chat message's `content` for a list of events: `@jini-ai/chat`'s own rule
+ * (`assistantContentFromEvents`, also what `useConversation` uses for a live turn), so a row the
+ * server finalizes reads the same as one the browser saved. That rule puts a paragraph break where a
+ * tool call or card sat between two text runs, so a working note is never glued onto the answer.
+ */
 /** Use the same paragraph-boundary rule as a live chat turn. */
 export declare function runContentFromEvents({ events }: {
     events: readonly AgentEvent[];
-}): string;
+}, _options?: Record<string, never>): string;
+/**
+ * The events to SAVE for a turn: streamed `text`/`thinking` deltas joined into one event per run
+ * (`@jini-ai/chat`'s `mergeAdjacentTextEvents`). Live, one event per few tokens is what streams words
+ * onto the screen; saved, it only repeats the event wrapper per token. Used by every saver (the server
+ * finalizer and the chat PUT route the browser saves through), so both write the same shape.
+ */
 /** Compact adjacent text/thinking deltas for durable storage. */
 export declare function runEventsForSave({ events }: {
     events: readonly AgentEvent[];
-}): AgentEvent[];
+}, _options?: Record<string, never>): AgentEvent[];
+/** What one daemon stream frame means for the turn: events to append, a failure, and whether it ended. */
+/** Set when the frame reports a failure. Once any frame has, the turn is `failed` (the browser's
+   *  `useRunStream` keeps an `'error'` status through a later `onDone`). */
+/** Set only on the `end` frame: the daemon's own terminal classification. */
 export interface RunFrameOutcome {
     readonly events: AgentEvent[];
     readonly error?: Error;
     readonly terminal?: Extract<ChatRunStatus, "succeeded" | "failed" | "canceled">;
 }
+/**
+ * Translates one named daemon SSE frame (`event:` name plus raw `data:` text) into its effect on the
+ * turn. The browser's `subscribeToRun` dispatches the result to `RunHandlers`; the server finalizer
+ * folds it into the row it saves. Never throws: a malformed frame yields no events rather than
+ * stranding either reader mid-turn.
+ *
+ * An `error` frame with no data is a connection error, not a run error — the browser's
+ * `EventSource` reports those on the same event name, so it must check for data before calling this.
+ *
+ * @complexity O(size of the frame).
+ */
 /** Fold one named daemon frame into events, a failure and an optional terminal status. */
 export declare function translateRunFrame({ kind, raw, notices }: {
     kind: string;
     raw: string | undefined;
     notices: RunNotices;
-}): RunFrameOutcome;
+}, _options?: Record<string, never>): RunFrameOutcome;
 //# sourceMappingURL=entry.d.ts.map