@basein/runner 0.2.12 → 0.3.1

package/dist/control/transcript.d.ts

@@ -17,7 +17,25 @@
  * defensive: an unknown shape yields `""` rather than throwing. Nothing here is
  * ever required for a recording to be valid — a missing context is a missing
  * nicety, not a failed step.
+ *
+ * READ INCREMENTALLY, NEVER WHOLE. Every hook used to `readFileSync` the whole
+ * transcript and `JSON.parse` every line of it — on the daemon's one thread,
+ * which also answers every other session's hooks. A transcript is append-only
+ * and grows for the life of a session; with screenshots and big tool outputs
+ * it reaches tens, then hundreds of MB. Measured: ~105 ms per parse at 31 MB,
+ * ~550 ms and a 1.3 GB heap at 156 MB, paid on *every* tool call and several
+ * times per Stop, with parallel tool calls queueing behind each other.
+ *
+ * So each path keeps a {@link TranscriptIndex}: the byte offset it has folded in
+ * and the few running answers the hooks ask for (usage totals, the last
+ * assistant text, the recent messages' text and thinking, this prompt's tool
+ * results). A call reads only the bytes appended since the last one. A file
+ * that shrank, was replaced, or was rewritten in place is noticed (size, inode,
+ * birth time, mtime, and the bytes at its head and at the offset) and read
+ * again from the start, which is exactly what the old code did every time.
  */
+/** Forget every cached index (tests; a caller that knows files were replaced). */
+export declare function forgetTranscripts(): void;
 /**
  * The last `n` tool results of the *current* prompt, redacted and capped.
  *
@@ -29,7 +47,9 @@
  * A transcript compacted mid-turn yields whatever follows that line, which may
  * be nothing; a transcript with no user prompt at all (a run opened by a proxy
  * step) yields nothing. Results with `is_error: true` are kept: a failure is
- * still the agent's evidence about what it is working on.
+ * still the agent's evidence about what it is working on. At most the last
+ * {@link MAX_RESULTS} are kept, each clipped to {@link MAX_RESULT_CHARS}
+ * characters before it is redacted and capped to `maxBytes`.
  */
 export declare function recentToolResults(transcriptPath: string | undefined, n?: number, maxBytes?: number): string[];
 /** Which rung of R-INTENT-1 a step's intent came from. */

package/dist/control/transcript.js

@@ -17,32 +17,26 @@
  * defensive: an unknown shape yields `""` rather than throwing. Nothing here is
  * ever required for a recording to be valid — a missing context is a missing
  * nicety, not a failed step.
+ *
+ * READ INCREMENTALLY, NEVER WHOLE. Every hook used to `readFileSync` the whole
+ * transcript and `JSON.parse` every line of it — on the daemon's one thread,
+ * which also answers every other session's hooks. A transcript is append-only
+ * and grows for the life of a session; with screenshots and big tool outputs
+ * it reaches tens, then hundreds of MB. Measured: ~105 ms per parse at 31 MB,
+ * ~550 ms and a 1.3 GB heap at 156 MB, paid on *every* tool call and several
+ * times per Stop, with parallel tool calls queueing behind each other.
+ *
+ * So each path keeps a {@link TranscriptIndex}: the byte offset it has folded in
+ * and the few running answers the hooks ask for (usage totals, the last
+ * assistant text, the recent messages' text and thinking, this prompt's tool
+ * results). A call reads only the bytes appended since the last one. A file
+ * that shrank, was replaced, or was rewritten in place is noticed (size, inode,
+ * birth time, mtime, and the bytes at its head and at the offset) and read
+ * again from the start, which is exactly what the old code did every time.
  */
-import { readFileSync } from "node:fs";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
 import { redactText } from "../record/redact.js";
 import { truncateString } from "../record/truncate.js";
-function readLines(transcriptPath) {
-    let raw;
-    try {
-        raw = readFileSync(transcriptPath, "utf8");
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        try {
-            out.push(JSON.parse(trimmed));
-        }
-        catch {
-            // Transcripts are appended concurrently; a half-written line is normal.
-        }
-    }
-    return out;
-}
 function blocksOf(line) {
     const content = line.message?.content ?? line.content;
     if (Array.isArray(content))
@@ -69,6 +63,344 @@ function resultTextOf(block) {
         return block.text;
     return "";
 }
+// ── the incremental index ───────────────────────────────────────────────────
+/** Bytes read per `readSync`. A line longer than this spans chunks. */
+const CHUNK_BYTES = 4 * 1024 * 1024;
+/**
+ * A line past this is skipped unparsed. Only a tool result carrying an image or
+ * a huge log gets here, and nothing read from a transcript needs more of one
+ * than its first few KB — while holding and parsing it would put a spike of
+ * that size on the daemon's heap.
+ */
+const MAX_LINE_BYTES = 32 * 1024 * 1024;
+/** How many bytes of the head, and of the tail before the offset, prove the file is the same file. */
+const PROBE_BYTES = 64;
+/** Transcripts indexed at once. One per live session; the oldest is forgotten first. */
+const MAX_INDEXES = 16;
+/*
+ * RETENTION. A recorder lives for days and holds up to {@link MAX_INDEXES}
+ * indexes, so what each one keeps is bounded by what the hooks actually ask
+ * for — not by what a transcript happens to contain. Extended thinking runs
+ * to tens of KB a message and tool outputs to megabytes; kept whole, sixteen
+ * busy sessions came to hundreds of MB that were never released.
+ */
+/**
+ * Messages whose text and thinking are kept, newest last. A `PreToolUse` asks
+ * about the call being made *now*, whose message is at the tail — every hook
+ * folds in what was appended since the last — so a hundred is generous.
+ */
+const MAX_MESSAGES = 128;
+/**
+ * Characters of one message's text, and separately of its thinking, kept.
+ * Text becomes a step's `context`; thinking is only embedded, and the intent
+ * probe sends 4,000 characters of either.
+ */
+const MAX_MESSAGE_CHARS = 16 * 1024;
+/** `tool_use_id`s remembered, newest last. */
+const MAX_TOOL_USES = 4_096;
+/** This prompt's tool results kept for derivation (R-PARAM-2 asks for 5 by default). */
+const MAX_RESULTS = 32;
+/** Characters of one tool result kept. Derivation reads 2 KB of each. */
+const MAX_RESULT_CHARS = 8 * 1024;
+/**
+ * Append `piece` to `into` while the total stays within
+ * {@link MAX_MESSAGE_CHARS}; the piece that crosses it is clipped, and
+ * anything after is dropped. Returns the new total.
+ */
+function keepWithin(into, held, piece) {
+    const room = MAX_MESSAGE_CHARS - held;
+    if (room <= 0)
+        return held;
+    const kept = piece.length > room ? piece.slice(0, room) : piece;
+    into.push(kept);
+    return held + kept.length;
+}
+const indexes = new Map();
+function freshIndex(st) {
+    return {
+        ino: st.ino,
+        birthtimeMs: st.birthtimeMs,
+        mtimeMs: st.mtimeMs,
+        offset: 0,
+        head: Buffer.alloc(0),
+        anchor: Buffer.alloc(0),
+        skipping: false,
+        lineNo: 0,
+        usage: new Map(),
+        usageSeen: new Set(),
+        lastAssistantText: "",
+        firstUserPrompt: "",
+        sawPrompt: false,
+        results: [],
+        messages: new Map(),
+        toolUses: new Map(),
+    };
+}
+/** Whether `idx` can be continued for a file that now looks like `st`. */
+function continues(idx, st) {
+    if (st.ino !== idx.ino || st.birthtimeMs !== idx.birthtimeMs)
+        return false; // replaced
+    if (st.size < idx.offset)
+        return false; // truncated, or compacted into a new file
+    // Same size, different mtime: rewritten in place. An append changes the size.
+    if (st.size === idx.offset && st.mtimeMs !== idx.mtimeMs)
+        return false;
+    return true;
+}
+/** Read exactly `length` bytes at `position`, or fewer at end of file. */
+function readAt(fd, position, length) {
+    const buf = Buffer.allocUnsafe(length);
+    let got = 0;
+    while (got < length) {
+        const n = readSync(fd, buf, got, length - got, position + got);
+        if (n <= 0)
+            break;
+        got += n;
+    }
+    return got === length ? buf : buf.subarray(0, got);
+}
+/**
+ * The index for `path`, caught up with whatever was appended since the last
+ * call. Undefined when the file cannot be read — which every caller treats as
+ * an empty transcript, as the whole-file reader always did.
+ */
+function indexFor(path) {
+    let st;
+    try {
+        st = statSync(path);
+    }
+    catch {
+        indexes.delete(path);
+        return undefined;
+    }
+    if (!st.isFile())
+        return undefined;
+    let idx = indexes.get(path);
+    // Re-inserted on every use, so the Map's order is least-recently-used first.
+    if (idx)
+        indexes.delete(path);
+    if (!idx || !continues(idx, st))
+        idx = freshIndex(st);
+    indexes.set(path, idx);
+    while (indexes.size > MAX_INDEXES) {
+        const oldest = indexes.keys().next().value;
+        if (oldest === undefined)
+            break;
+        indexes.delete(oldest);
+    }
+    if (st.size === idx.offset)
+        return idx;
+    try {
+        return catchUp(path, idx, st);
+    }
+    catch {
+        // Unreadable mid-way (locked, deleted): what was folded in so far stands.
+        return indexes.get(path);
+    }
+}
+/** Fold in what was appended; the index to use from now on (a fresh one after a rewrite). */
+function catchUp(path, stale, st) {
+    const fd = openSync(path, "r");
+    try {
+        let idx = stale;
+        if (idx.offset > 0) {
+            // The same size-and-inode can hide a rewrite: prove the bytes we already
+            // folded in are still there, at the head and just before the offset.
+            const head = readAt(fd, 0, idx.head.length);
+            const anchorAt = idx.offset - idx.anchor.length;
+            const anchor = readAt(fd, anchorAt, idx.anchor.length);
+            if (!head.equals(idx.head) || !anchor.equals(idx.anchor)) {
+                idx = freshIndex(st);
+                indexes.set(path, idx);
+            }
+        }
+        fold(idx, fd, st.size);
+        idx.mtimeMs = st.mtimeMs;
+        if (idx.head.length < PROBE_BYTES)
+            idx.head = readAt(fd, 0, Math.min(PROBE_BYTES, idx.offset));
+        const anchorLength = Math.min(PROBE_BYTES, idx.offset);
+        idx.anchor = readAt(fd, idx.offset - anchorLength, anchorLength);
+        return idx;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Fold the bytes from `idx.offset` to `size` into `idx`, line by line.
+ *
+ * Only whole lines advance the offset. The last, unterminated line is folded in
+ * when it already parses — a writer that ends the file without a newline has
+ * still written a complete line — and otherwise left for the next call:
+ * transcripts are appended concurrently, and a half-written line is normal.
+ */
+function fold(idx, fd, size) {
+    let position = idx.offset;
+    /** Bytes of the line in progress, from earlier chunks of this pass. */
+    let pending = [];
+    let pendingBytes = 0;
+    while (position < size) {
+        const chunk = readAt(fd, position, Math.min(CHUNK_BYTES, size - position));
+        if (chunk.length === 0)
+            break;
+        const chunkStart = position;
+        position += chunk.length;
+        let start = 0;
+        for (;;) {
+            const nl = chunk.indexOf(0x0a, start);
+            if (nl === -1)
+                break;
+            if (idx.skipping) {
+                idx.skipping = false;
+            }
+            else {
+                const line = pendingBytes > 0 ? Buffer.concat([...pending, chunk.subarray(start, nl)]) : chunk.subarray(start, nl);
+                ingest(idx, line);
+            }
+            pending = [];
+            pendingBytes = 0;
+            start = nl + 1;
+            idx.offset = chunkStart + start;
+        }
+        if (start < chunk.length && !idx.skipping) {
+            // Copied: a subarray would pin the whole 4 MB chunk.
+            pending.push(Buffer.from(chunk.subarray(start)));
+            pendingBytes += chunk.length - start;
+            if (pendingBytes > MAX_LINE_BYTES) {
+                idx.skipping = true;
+                pending = [];
+                pendingBytes = 0;
+            }
+        }
+        if (idx.skipping)
+            idx.offset = position; // skipped bytes are consumed bytes
+    }
+    if (pendingBytes > 0 && !idx.skipping) {
+        const tail = Buffer.concat(pending);
+        const parsed = parse(tail);
+        if (parsed) {
+            foldLine(idx, parsed);
+            idx.offset = position;
+        }
+    }
+}
+function parse(bytes) {
+    const text = bytes.toString("utf8").trim();
+    if (!text)
+        return undefined;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function ingest(idx, bytes) {
+    const line = parse(bytes);
+    // A terminated line that does not parse is corrupt, not half-written: skip it.
+    if (line)
+        foldLine(idx, line);
+}
+/** What one line contributes to every answer this module gives. */
+function foldLine(idx, line) {
+    idx.lineNo += 1;
+    const message = line.message;
+    const role = message?.role ?? line.type;
+    const blocks = blocksOf(line);
+    // Usage, deduplicated by message id (see `totalUsage`'s note on why).
+    const usage = message?.usage;
+    if (usage && typeof usage === "object") {
+        const id = message?.id;
+        if (!id || !idx.usageSeen.has(id)) {
+            if (id)
+                idx.usageSeen.add(id);
+            const model = message?.model ?? "unknown";
+            const acc = idx.usage.get(model) ?? zeroUsage(model);
+            acc.inputTokens += usage.input_tokens ?? 0;
+            acc.outputTokens += usage.output_tokens ?? 0;
+            acc.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
+            acc.cacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+            idx.usage.set(model, acc);
+        }
+    }
+    if (role === "assistant") {
+        const text = textOf(blocks);
+        if (text)
+            idx.lastAssistantText = text;
+    }
+    else if (role === "user") {
+        // A user line carrying text is a prompt: "this prompt's results" start
+        // again from it, its own tool results included.
+        const text = textOf(blocks);
+        if (text) {
+            if (!idx.sawPrompt)
+                idx.firstUserPrompt = text;
+            idx.sawPrompt = true;
+            idx.results = [];
+        }
+        if (idx.sawPrompt) {
+            for (const block of blocks) {
+                if (block.type !== "tool_result")
+                    continue;
+                const result = resultTextOf(block);
+                if (!result)
+                    continue;
+                idx.results.push(result.length > MAX_RESULT_CHARS ? result.slice(0, MAX_RESULT_CHARS) : result);
+                if (idx.results.length > MAX_RESULTS)
+                    idx.results.shift();
+            }
+        }
+    }
+    // Intent: every line of a multi-block message repeats its `message.id`, so a
+    // tool call's text and thinking are gathered from its siblings (R-INTENT-3).
+    const toolUses = blocks.filter((b) => b.type === "tool_use" && typeof b.id === "string");
+    const messageId = message?.id;
+    // No `message.id`: an older transcript or a fixture, where the line is the
+    // whole message. Only such a line holding a tool call is worth keeping.
+    if (!messageId && toolUses.length === 0)
+        return;
+    const key = messageId ?? `#line${idx.lineNo}`;
+    let entry = idx.messages.get(key);
+    if (!entry) {
+        entry = { texts: [], thinkings: [], textChars: 0, thinkingChars: 0 };
+        idx.messages.set(key, entry);
+        if (idx.messages.size > MAX_MESSAGES) {
+            const oldest = idx.messages.keys().next().value;
+            if (oldest !== undefined)
+                idx.messages.delete(oldest);
+        }
+    }
+    for (const b of blocks) {
+        if (b.type === "text" && typeof b.text === "string") {
+            entry.textChars = keepWithin(entry.texts, entry.textChars, b.text);
+        }
+        else if (b.type === "thinking" && typeof b.thinking === "string") {
+            entry.thinkingChars = keepWithin(entry.thinkings, entry.thinkingChars, b.thinking);
+        }
+    }
+    if (toolUses.length === 0)
+        return;
+    const whole = textOf(blocks);
+    const ownText = whole.length > MAX_MESSAGE_CHARS ? whole.slice(0, MAX_MESSAGE_CHARS) : whole;
+    for (const use of toolUses) {
+        const id = use.id;
+        // The first line holding the call is the one that counts, as before.
+        if (idx.toolUses.has(id))
+            continue;
+        idx.toolUses.set(id, { message: key, ownText });
+        if (idx.toolUses.size > MAX_TOOL_USES) {
+            const oldest = idx.toolUses.keys().next().value;
+            if (oldest !== undefined)
+                idx.toolUses.delete(oldest);
+        }
+    }
+}
+/** Forget every cached index (tests; a caller that knows files were replaced). */
+export function forgetTranscripts() {
+    indexes.clear();
+}
+// ── accessors ───────────────────────────────────────────────────────────────
 /**
  * The last `n` tool results of the *current* prompt, redacted and capped.
  *
@@ -80,38 +412,17 @@ function resultTextOf(block) {
  * A transcript compacted mid-turn yields whatever follows that line, which may
  * be nothing; a transcript with no user prompt at all (a run opened by a proxy
  * step) yields nothing. Results with `is_error: true` are kept: a failure is
- * still the agent's evidence about what it is working on.
+ * still the agent's evidence about what it is working on. At most the last
+ * {@link MAX_RESULTS} are kept, each clipped to {@link MAX_RESULT_CHARS}
+ * characters before it is redacted and capped to `maxBytes`.
  */
 export function recentToolResults(transcriptPath, n = 5, maxBytes = 2048) {
     if (!transcriptPath || n <= 0)
         return [];
-    const lines = readLines(transcriptPath);
-    let start = -1;
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-        const role = lines[i].message?.role ?? lines[i].type;
-        if (role !== "user")
-            continue;
-        if (textOf(blocksOf(lines[i]))) {
-            start = i;
-            break;
-        }
-    }
-    if (start === -1)
+    const idx = indexFor(transcriptPath);
+    if (!idx || !idx.sawPrompt)
         return [];
-    const out = [];
-    for (let i = start; i < lines.length; i += 1) {
-        const role = lines[i].message?.role ?? lines[i].type;
-        if (role !== "user")
-            continue;
-        for (const block of blocksOf(lines[i])) {
-            if (block.type !== "tool_result")
-                continue;
-            const text = resultTextOf(block);
-            if (text)
-                out.push(text);
-        }
-    }
-    return out.slice(-n).map((t) => truncateString(redactText(t), maxBytes));
+    return idx.results.slice(-n).map((t) => truncateString(redactText(t), maxBytes));
 }
 /**
  * The intent of one tool call, read the way the transcript really stores it
@@ -134,28 +445,18 @@ export function recentToolResults(transcriptPath, n = 5, maxBytes = 2048) {
 export function intentForToolUse(transcriptPath, toolUseId, sources = new Set(["text", "thinking", "tool"])) {
     if (!transcriptPath || !toolUseId)
         return undefined;
-    const lines = readLines(transcriptPath);
-    const holder = lines.find((line) => blocksOf(line).some((b) => b.type === "tool_use" && b.id === toolUseId));
-    if (!holder)
+    const idx = indexFor(transcriptPath);
+    const holder = idx?.toolUses.get(toolUseId);
+    const message = holder ? idx?.messages.get(holder.message) : undefined;
+    if (!message)
         return undefined;
-    // No `message.id` means an older transcript, or a hand-written fixture: the
-    // line is the whole message and there are no siblings to gather.
-    const messageId = holder.message?.id;
-    const siblings = messageId
-        ? lines.filter((line) => line.message?.id === messageId)
-        : [holder];
     if (sources.has("text")) {
-        const text = textOf(siblings.flatMap((line) => blocksOf(line)));
+        const text = message.texts.join("\n").trim();
         if (text)
             return { text, source: "text" };
     }
     if (sources.has("thinking")) {
-        const thinking = siblings
-            .flatMap((line) => blocksOf(line))
-            .filter((b) => b.type === "thinking" && typeof b.thinking === "string")
-            .map((b) => b.thinking)
-            .join("\n")
-            .trim();
+        const thinking = message.thinkings.join("\n").trim();
         if (thinking)
             return { text: thinking, source: "thinking" };
     }
@@ -165,29 +466,13 @@ export function intentForToolUse(transcriptPath, toolUseId, sources = new Set(["
 export function contextForToolUse(transcriptPath, toolUseId) {
     if (!transcriptPath || !toolUseId)
         return "";
-    for (const line of readLines(transcriptPath)) {
-        const blocks = blocksOf(line);
-        if (blocks.some((b) => b.type === "tool_use" && b.id === toolUseId)) {
-            return textOf(blocks);
-        }
-    }
-    return "";
+    return indexFor(transcriptPath)?.toolUses.get(toolUseId)?.ownText ?? "";
 }
 /** The last assistant text in the transcript — the turn's final answer. */
 export function lastAssistantText(transcriptPath) {
     if (!transcriptPath)
         return "";
-    const lines = readLines(transcriptPath);
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-        const line = lines[i];
-        const role = line.message?.role ?? line.type;
-        if (role !== "assistant")
-            continue;
-        const text = textOf(blocksOf(line));
-        if (text)
-            return text;
-    }
-    return "";
+    return indexFor(transcriptPath)?.lastAssistantText ?? "";
 }
 /**
  * The turn's final answer, waiting briefly for the transcript to catch up.
@@ -251,28 +536,17 @@ const zeroUsage = (model) => ({
  *
  * A line with no `message.id` is counted once on its own (older transcripts, and
  * anything hand-written in a test).
+ *
+ * The running totals live in the index ({@link foldLine}); this returns a copy,
+ * because a mark is kept and compared long after the index has moved on.
  */
 function totalUsage(transcriptPath) {
     const totals = new Map();
-    const seen = new Set();
-    for (const line of readLines(transcriptPath)) {
-        const usage = line.message?.usage;
-        if (!usage)
-            continue;
-        const id = line.message?.id;
-        if (id) {
-            if (seen.has(id))
-                continue;
-            seen.add(id);
-        }
-        const model = line.message?.model ?? "unknown";
-        const acc = totals.get(model) ?? zeroUsage(model);
-        acc.inputTokens += usage.input_tokens ?? 0;
-        acc.outputTokens += usage.output_tokens ?? 0;
-        acc.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
-        acc.cacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
-        totals.set(model, acc);
-    }
+    const idx = indexFor(transcriptPath);
+    if (!idx)
+        return totals;
+    for (const [model, u] of idx.usage)
+        totals.set(model, { ...u });
     return totals;
 }
 /**
@@ -333,14 +607,6 @@ export function usageSince(transcriptPath, mark) {
 export function firstUserPrompt(transcriptPath) {
     if (!transcriptPath)
         return "";
-    for (const line of readLines(transcriptPath)) {
-        const role = line.message?.role ?? line.type;
-        if (role !== "user")
-            continue;
-        const text = textOf(blocksOf(line));
-        if (text)
-            return text;
-    }
-    return "";
+    return indexFor(transcriptPath)?.firstUserPrompt ?? "";
 }
 //# sourceMappingURL=transcript.js.map

package/dist/index.d.ts

@@ -26,7 +26,7 @@ export * from "./control/discovery.js";
 export * from "./control/paths.js";
 export * from "./record/recorder.js";
 export { RemoteRecorder } from "./record/remote-recorder.js";
-export { redact, redactText, REDACTED } from "./record/redact.js";
+export { redact, redactText, redactJsonText, REDACTED } from "./record/redact.js";
 export { serializeCapped, truncateString, truncateStrings, DEFAULT_MAX_PAYLOAD_BYTES, } from "./record/truncate.js";
 export { StepQueue } from "./record/queue.js";
 export * from "./config/resolve.js";
@@ -34,4 +34,8 @@ export * from "./config/generate.js";
 export { authenticate, loadCredentials, saveCredentials, clearCredentials } from "./auth/client.js";
 export type { AuthSession, AuthUser } from "./auth/client.js";
 export { logLine, logDetail } from "./util/log.js";
+export { isRunnerOff, offSource, setRunnerOff, offFlagPath, projectOffFlagPath } from "./util/off-switch.js";
+export type { OffSource } from "./util/off-switch.js";
+export { serviceHealth, ServiceHealth, awaitWithin, timeoutSignal, serviceTimeoutMs, isUnhealthyStatus } from "./util/service-health.js";
+export type { HealthSnapshot, ServiceHealthOptions } from "./util/service-health.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -22,11 +22,15 @@ export * from "./control/discovery.js";
 export * from "./control/paths.js";
 export * from "./record/recorder.js";
 export { RemoteRecorder } from "./record/remote-recorder.js";
-export { redact, redactText, REDACTED } from "./record/redact.js";
+export { redact, redactText, redactJsonText, REDACTED } from "./record/redact.js";
 export { serializeCapped, truncateString, truncateStrings, DEFAULT_MAX_PAYLOAD_BYTES, } from "./record/truncate.js";
 export { StepQueue } from "./record/queue.js";
 export * from "./config/resolve.js";
 export * from "./config/generate.js";
 export { authenticate, loadCredentials, saveCredentials, clearCredentials } from "./auth/client.js";
 export { logLine, logDetail } from "./util/log.js";
+// An embedder hosting its own control server honours the same kill switch
+// (`bir off`) and reads the same verdict on the service as the binaries do.
+export { isRunnerOff, offSource, setRunnerOff, offFlagPath, projectOffFlagPath } from "./util/off-switch.js";
+export { serviceHealth, ServiceHealth, awaitWithin, timeoutSignal, serviceTimeoutMs, isUnhealthyStatus } from "./util/service-health.js";
 //# sourceMappingURL=index.js.map