@giovannijecha/jecode 0.8.2 → 0.8.4

package/dist/context/estimate.js

@@ -2,8 +2,25 @@
 import { constants, deflateRawSync } from "node:zlib";
 const BYTES_PER_TOKEN = 3;
 const COMPRESSED_BYTES_PER_TOKEN = 5 / 6;
+const SERIALIZED_CHUNK_CODE_UNITS = 64 * 1_024;
 export function estimateSerializedTokens(value) {
-    const serialized = Buffer.from(JSON.stringify(value), "utf8");
+    let tokens = 0;
+    for (const serialized of serializedChunks(value))
+        tokens += estimateChunk(serialized);
+    return tokens;
+}
+/** Estimate the same conservative value while yielding between bounded chunks. */
+export async function estimateSerializedTokensResponsive(value, signal) {
+    let tokens = 0;
+    for (const serialized of serializedChunks(value)) {
+        throwIfAborted(signal);
+        tokens += estimateChunk(serialized);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    throwIfAborted(signal);
+    return tokens;
+}
+function estimateChunk(serialized) {
     const compressedBytes = deflateRawSync(serialized, {
         level: constants.Z_BEST_SPEED,
     }).byteLength;
@@ -14,6 +31,20 @@ export function estimateSerializedTokens(value) {
     // floor, including when repeated input compresses unusually well.
     return Math.min(serialized.byteLength, Math.max(Math.ceil(serialized.byteLength / BYTES_PER_TOKEN), Math.ceil(compressedBytes / COMPRESSED_BYTES_PER_TOKEN), literalTokens));
 }
+function* serializedChunks(value) {
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined)
+        throw new TypeError("value is not JSON-serializable");
+    for (let start = 0; start < serialized.length;) {
+        let end = Math.min(serialized.length, start + SERIALIZED_CHUNK_CODE_UNITS);
+        if (end < serialized.length &&
+            highSurrogate(serialized.charCodeAt(end - 1)) &&
+            lowSurrogate(serialized.charCodeAt(end)))
+            end--;
+        yield Buffer.from(serialized.slice(start, end), "utf8");
+        start = end;
+    }
+}
 function literalTokenFloor(serialized) {
     let compactableAscii = 0;
     let literalBytes = 0;
@@ -29,3 +60,14 @@ function literalTokenFloor(serialized) {
     }
     return literalBytes + Math.ceil(compactableAscii / BYTES_PER_TOKEN);
 }
+function highSurrogate(value) {
+    return value >= 0xd800 && value <= 0xdbff;
+}
+function lowSurrogate(value) {
+    return value >= 0xdc00 && value <= 0xdfff;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("aborted");
+}

package/dist/context/manual.js

@@ -6,14 +6,15 @@
 import { recordAuxiliaryUsage } from "../usage.js";
 import { resolveContextPolicy } from "./capacity.js";
 import { compactContext } from "./compactor.js";
-import { estimateTokens, planCompaction } from "./policy.js";
+import { estimateTokensResponsive, planCompaction } from "./policy.js";
 const MIN_PREFIX_TOKENS = 512;
 export async function compactSession(session, options = {}) {
     const active = session.conversation.activeNode;
     if (active === undefined)
         return "unchanged";
     const context = session.conversation.contextHistory;
-    if (estimateTokens(context) < MIN_PREFIX_TOKENS)
+    const estimatedInputTokens = await estimateTokensResponsive(context, options.signal);
+    if (estimatedInputTokens < MIN_PREFIX_TOKENS)
         return "unchanged";
     if (session.conversation.nodes.some((node) => node.parentId === active.id)) {
         throw new Error("continue this branch before compacting");
@@ -29,8 +30,9 @@ export async function compactSession(session, options = {}) {
     const coveredMessages = active.context?.throughNodeId === active.id
         ? active.context.messageCount
         : 0;
-    const plan = planCompaction(context, active.messages, coveredMessages, session.usage.lastInputTokens, true, policy);
-    if (plan === undefined || estimateTokens(plan.prefix) < MIN_PREFIX_TOKENS) {
+    const plan = await planCompaction(context, active.messages, coveredMessages, session.usage.lastInputTokens, true, policy, estimatedInputTokens, options.signal);
+    if (plan === undefined ||
+        await estimateTokensResponsive(plan.prefix, options.signal) < MIN_PREFIX_TOKENS) {
         options.onStatus?.();
         return "unchanged";
     }
@@ -43,6 +45,8 @@ export async function compactSession(session, options = {}) {
         nodeId: active.id,
         coveredMessages,
         lastInputTokens: session.usage.lastInputTokens,
+        estimatedInputTokens,
+        precomputedPlan: plan,
         signal: options.signal,
         force: true,
         failLoudly: true,

package/dist/context/policy.js

@@ -1,15 +1,18 @@
 // Provider-neutral context pressure and safe compaction boundaries.
-import { estimateSerializedTokens } from "./estimate.js";
+import { estimateSerializedTokens, estimateSerializedTokensResponsive, } from "./estimate.js";
 export const DEFAULT_COMPACTION_PERCENT = 85;
 export const MIN_COMPACTION_PERCENT = 50;
 export const MAX_COMPACTION_PERCENT = 95;
 export const FALLBACK_CONTEXT_WINDOW_TOKENS = 200_000;
 export const REQUEST_ESTIMATE_HEADROOM_PERCENT = 5;
 export const MIN_REQUEST_OUTPUT_TOKENS = 256;
-export function planCompaction(context, turn, coveredMessages, lastInputTokens, force, policy) {
+export async function planCompaction(context, turn, coveredMessages, lastInputTokens, force, policy, estimatedInputTokens, signal) {
     if (!validPolicy(policy) || coveredMessages < 0 || coveredMessages > turn.length)
         return undefined;
-    const estimated = estimateTokens(context);
+    if (estimatedInputTokens !== undefined &&
+        (!Number.isSafeInteger(estimatedInputTokens) || estimatedInputTokens <= 0))
+        return undefined;
+    const estimated = estimatedInputTokens ?? await estimateTokensResponsive(context, signal);
     if (!force &&
         (estimated < policy.targetTokens || Math.max(estimated, lastInputTokens) < policy.triggerTokens))
         return undefined;
@@ -17,15 +20,16 @@ export function planCompaction(context, turn, coveredMessages, lastInputTokens,
     const contextPrefix = context.length - currentSuffix;
     if (contextPrefix < 0)
         return undefined;
-    if (!sameMessages(context.slice(contextPrefix), turn.slice(coveredMessages)))
+    if (!await sameMessages(context.slice(contextPrefix), turn.slice(coveredMessages), signal))
         return undefined;
     const targetTokens = force
         ? Math.min(policy.targetTokens, Math.max(512, Math.floor(estimated / 4)))
         : policy.targetTokens;
     const recentTokens = Math.min(policy.recentTokens, Math.max(256, Math.floor(targetTokens / 2)));
-    let boundary = recentBoundary(turn, coveredMessages, recentTokens);
+    const recent = await recentBoundary(turn, coveredMessages, recentTokens, signal);
+    let boundary = recent.boundary;
     let tail = turn.slice(boundary);
-    if (turn.length > 1 && estimateTokens(tail) > targetTokens) {
+    if (turn.length > 1 && recent.tokens > targetTokens) {
         boundary = turn.length;
         tail = [];
     }
@@ -33,8 +37,9 @@ export function planCompaction(context, turn, coveredMessages, lastInputTokens,
     if (prefixEnd <= 0 || prefixEnd > context.length)
         return undefined;
     const prefix = context.slice(0, prefixEnd);
-    if (!force && estimateTokens(prefix) < policy.minimumPrefixTokens)
+    if (!force && await estimateTokensResponsive(prefix, signal) < policy.minimumPrefixTokens) {
         return undefined;
+    }
     return {
         prefix: clone(prefix),
         tail: clone(tail),
@@ -70,6 +75,9 @@ export function policyForContextWindow(context, compactionPercent) {
 export function estimateTokens(messages) {
     return estimateSerializedTokens(messages) + messages.length * 8;
 }
+export async function estimateTokensResponsive(messages, signal) {
+    return await estimateSerializedTokensResponsive(messages, signal) + messages.length * 8;
+}
 export function isContextOverflow(error) {
     const candidate = error;
     if (candidate.status !== 400 && candidate.status !== 413)
@@ -77,16 +85,45 @@ export function isContextOverflow(error) {
     const detail = `${candidate.message}\n${candidate.body ?? ""}`;
     return /context_length_exceeded|maximum context length|context window|prompt is too long|input (?:is )?too (?:long|large)|(?:input|prompt|context).{0,80}(?:exceed|maximum|max tokens)/i.test(detail);
 }
-function recentBoundary(turn, coveredMessages, recentTokens) {
-    let boundary = minimumRecentBoundary(turn);
-    for (let candidate = boundary - 1; candidate >= coveredMessages; candidate--) {
-        if (!safeBoundary(turn, candidate))
-            continue;
-        if (estimateTokens(turn.slice(candidate)) > recentTokens)
-            break;
-        boundary = candidate;
+async function recentBoundary(turn, coveredMessages, recentTokens, signal) {
+    const minimum = Math.max(coveredMessages, minimumRecentBoundary(turn));
+    const candidates = [];
+    for (let candidate = coveredMessages; candidate <= minimum; candidate++) {
+        if (candidate === minimum || safeBoundary(turn, candidate))
+            candidates.push(candidate);
+    }
+    const cache = new Map();
+    const estimateAt = (candidate) => {
+        let estimate = cache.get(candidate);
+        if (estimate === undefined) {
+            estimate = estimateTokensResponsive(turn.slice(candidate), signal);
+            cache.set(candidate, estimate);
+        }
+        return estimate;
+    };
+    const last = candidates.length - 1;
+    const minimumTokens = await estimateAt(candidates[last]);
+    if (minimumTokens > recentTokens) {
+        return { boundary: candidates[last], tokens: minimumTokens };
     }
-    return Math.max(coveredMessages, boundary);
+    // Adding older messages raises the byte and literal floors. A lower-bound
+    // search therefore replaces the former serialization of every suffix.
+    let low = 0;
+    let high = last;
+    let selected = last;
+    while (low <= high) {
+        const middle = Math.floor((low + high) / 2);
+        const tokens = await estimateAt(candidates[middle]);
+        if (tokens <= recentTokens) {
+            selected = middle;
+            high = middle - 1;
+        }
+        else {
+            low = middle + 1;
+        }
+    }
+    const boundary = candidates[selected];
+    return { boundary, tokens: await estimateAt(boundary) };
 }
 function minimumRecentBoundary(turn) {
     const last = turn.at(-1);
@@ -127,8 +164,21 @@ function validPercent(value) {
     return Number.isSafeInteger(value) &&
         value >= MIN_COMPACTION_PERCENT && value <= MAX_COMPACTION_PERCENT;
 }
-function sameMessages(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+async function sameMessages(left, right, signal) {
+    if (left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; index++) {
+        throwIfAborted(signal);
+        if (JSON.stringify(left[index]) !== JSON.stringify(right[index]))
+            return false;
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return true;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("aborted");
 }
 function clone(value) {
     return structuredClone(value);

package/dist/controller-request.js

@@ -1,9 +1,9 @@
 // One streamed provider request with a single safe context-overflow recovery.
-import { budgetRequestFromInputTokens, estimateRequestInputTokens, } from "./context/budget.js";
+import { budgetRequestFromInputTokens, estimateRequestInputTokensResponsive, } from "./context/budget.js";
 import { isContextOverflow } from "./context/policy.js";
 export async function requestAssistant(history, current, specs, options, events, signal) {
     let policy = await options.contextPolicy();
-    const prepared = await prepareContext(history, current, specs, options, events, policy, "budget");
+    const prepared = await prepareContext(history, current, specs, options, events, policy, "budget", signal);
     let context = prepared.projected === undefined ? [...current] : clone(prepared.projected);
     let inputTokens = prepared.inputTokens;
     let recovered = false;
@@ -28,7 +28,7 @@ export async function requestAssistant(history, current, specs, options, events,
                 throw error;
             if (isContextOverflow(error))
                 policy = await options.contextPolicy();
-            const next = await prepareContext(history, context, specs, options, events, policy, "overflow", error);
+            const next = await prepareContext(history, context, specs, options, events, policy, "overflow", signal, error, inputTokens);
             if (next.projected === undefined)
                 throw error;
             context = clone(next.projected);
@@ -37,12 +37,12 @@ export async function requestAssistant(history, current, specs, options, events,
         }
     }
 }
-async function prepareContext(history, context, specs, options, events, policy, reason, error) {
-    const inputTokens = estimateRequestInputTokens({
+async function prepareContext(history, context, specs, options, events, policy, reason, signal, error, knownInputTokens) {
+    const inputTokens = knownInputTokens ?? await estimateRequestInputTokensResponsive({
         system: options.system,
         messages: context,
         tools: specs,
-    });
+    }, signal);
     const projected = await events.onContext?.(history, context, {
         reason,
         policy,
@@ -53,11 +53,11 @@ async function prepareContext(history, context, specs, options, events, policy,
         projected,
         inputTokens: projected === undefined
             ? inputTokens
-            : estimateRequestInputTokens({
+            : await estimateRequestInputTokensResponsive({
                 system: options.system,
                 messages: projected,
                 tools: specs,
-            }),
+            }, signal),
     };
 }
 function clone(messages) {

package/dist/controller.js

@@ -185,11 +185,14 @@ function assertToolCallIds(calls) {
     }
 }
 async function settle(call, current, total, options, events, signal, preview) {
+    throwIfAborted(signal);
+    if (call.inputError !== undefined) {
+        return refuse(call, call.inputError, "invalid arguments");
+    }
     const tool = findTool(options.tools, call.name);
     if (tool === undefined) {
         return refuse(call, `no such tool: ${call.name}`, "unknown tool");
     }
-    throwIfAborted(signal);
     const approved = !tool.dangerous || await events.approve(call);
     throwIfAborted(signal);
     if (!approved) {
@@ -218,6 +221,8 @@ function refuse(call, reason, summary) {
  * turn depends on it, because it exists for the user, not for the model.
  */
 async function look(call, options, signal) {
+    if (call.inputError !== undefined)
+        return undefined;
     const tool = findTool(options.tools, call.name);
     if (tool?.preview === undefined)
         return undefined;

package/dist/conversation.js

@@ -16,13 +16,17 @@ export const CONVERSATION_LIMITS = Object.freeze({
 export class ConversationTree {
     #nodes;
     #activeNodeId;
-    constructor(nodes, activeNodeId) {
-        this.#nodes = Object.freeze([...nodes]);
+    #nodeBounds;
+    #bounds;
+    constructor(nodes, activeNodeId, nodeBounds, bounds) {
+        this.#nodes = nodes;
         this.#activeNodeId = activeNodeId;
+        this.#nodeBounds = nodeBounds;
+        this.#bounds = bounds;
         Object.freeze(this);
     }
     static empty() {
-        return new ConversationTree([], 0);
+        return new ConversationTree(Object.freeze([]), 0, Object.freeze([]), emptyBounds());
     }
     static restore(nodes, activeNodeId) {
         if (nodes.length > CONVERSATION_LIMITS.nodes) {
@@ -39,11 +43,13 @@ export class ConversationTree {
             assertPersistableNode(owned);
             restored.push(owned);
         }
-        assertBounds(restored);
+        const measured = measureBounds(restored);
+        assertBounds(measured.total);
+        assertContextPaths(restored, restored.filter((node) => node.context !== undefined));
         if (!validNodeId(activeNodeId) ||
             (activeNodeId !== 0 && restored[activeNodeId - 1]?.id !== activeNodeId))
             throw new Error("conversation node does not exist");
-        return new ConversationTree(restored, activeNodeId);
+        return new ConversationTree(Object.freeze(restored), activeNodeId, Object.freeze(measured.nodes), measured.total);
     }
     /** Commit or extend the one prospective leaf turn. */
     commit(draft, settlement) {
@@ -60,7 +66,7 @@ export class ConversationTree {
         if (!validNodeId(nodeId) || (nodeId !== 0 && this.#nodes[nodeId - 1]?.id !== nodeId)) {
             throw new Error("conversation node does not exist");
         }
-        return new ConversationTree(this.#nodes, nodeId);
+        return new ConversationTree(this.#nodes, nodeId, this.#nodeBounds, this.#bounds);
     }
     node(nodeId) {
         return nodeId === 0 ? undefined : this.#nodes[nodeId - 1];
@@ -132,9 +138,11 @@ export class ConversationTree {
         });
         assertTurn(node);
         assertPersistableNode(node);
-        const nodes = [...this.#nodes, node];
-        assertBounds(nodes);
-        return new ConversationTree(nodes, node.id);
+        assertContextPath(this.#nodes, node);
+        const nodeBounds = measureNode(node);
+        const bounds = addBounds(this.#bounds, nodeBounds);
+        assertBounds(bounds);
+        return new ConversationTree(Object.freeze([...this.#nodes, node]), node.id, Object.freeze([...this.#nodeBounds, nodeBounds]), bounds);
     }
     #replace(draft, settlement) {
         const id = draft.nodeId;
@@ -154,10 +162,16 @@ export class ConversationTree {
         });
         assertTurn(node);
         assertPersistableNode(node);
+        assertContextPath(this.#nodes, node);
         const nodes = [...this.#nodes];
         nodes[id - 1] = node;
-        assertBounds(nodes);
-        return new ConversationTree(nodes, id);
+        const priorBounds = this.#nodeBounds[id - 1];
+        const nextNodeBounds = measureNode(node);
+        const nodeBounds = [...this.#nodeBounds];
+        nodeBounds[id - 1] = nextNodeBounds;
+        const bounds = replaceBounds(this.#bounds, priorBounds, nextNodeBounds);
+        assertBounds(bounds);
+        return new ConversationTree(Object.freeze(nodes), id, Object.freeze(nodeBounds), bounds);
     }
     #path() {
         const path = [];
@@ -174,13 +188,13 @@ export class ConversationTree {
     }
 }
 function ownedNode(node) {
-    return Object.freeze({
+    return deepFreeze({
         ...node,
-        identity: Object.freeze({ ...node.identity }),
-        messages: Object.freeze(clone(node.messages)),
-        blocks: Object.freeze(clone(node.blocks)),
-        ...(node.context === undefined ? {} : { context: Object.freeze({ ...node.context }) }),
-        ...(node.failure === undefined ? {} : { failure: Object.freeze({ ...node.failure }) }),
+        identity: { ...node.identity },
+        messages: clone(node.messages),
+        blocks: clone(node.blocks),
+        ...(node.context === undefined ? {} : { context: { ...node.context } }),
+        ...(node.failure === undefined ? {} : { failure: { ...node.failure } }),
     });
 }
 function settledBlocks(blocks) {
@@ -225,28 +239,64 @@ function validSettlement(value) {
     return value === "checkpointed" || value === "completed" ||
         value === "failed" || value === "interrupted";
 }
-function assertBounds(nodes) {
-    let messageCodeUnits = 0;
-    let transcriptCodeUnits = 0;
-    let contextCodeUnits = 0;
-    const contextOwners = [];
-    for (const node of nodes) {
-        messageCodeUnits += JSON.stringify(node.messages).length;
-        transcriptCodeUnits += JSON.stringify(node.blocks).length;
-        contextCodeUnits += node.context?.summary.length ?? 0;
-        if (node.context !== undefined)
-            contextOwners.push(node);
-    }
-    if (messageCodeUnits > CONVERSATION_LIMITS.messageCodeUnits) {
+function assertBounds(bounds) {
+    if (bounds.messageCodeUnits > CONVERSATION_LIMITS.messageCodeUnits) {
         throw new Error("conversation model history reached its session limit — start /new");
     }
-    if (transcriptCodeUnits > CONVERSATION_LIMITS.transcriptCodeUnits) {
+    if (bounds.transcriptCodeUnits > CONVERSATION_LIMITS.transcriptCodeUnits) {
         throw new Error("conversation transcript reached its session limit — start /new");
     }
-    if (contextCodeUnits > CONVERSATION_LIMITS.contextCodeUnits) {
+    if (bounds.contextCodeUnits > CONVERSATION_LIMITS.contextCodeUnits) {
         throw new Error("conversation context summaries reached their session limit — start /new");
     }
-    assertContextPaths(nodes, contextOwners);
+}
+function measureBounds(nodes) {
+    const measured = nodes.map(measureNode);
+    return {
+        nodes: measured,
+        total: measured.reduce(addBounds, emptyBounds()),
+    };
+}
+function measureNode(node) {
+    return Object.freeze({
+        messageCodeUnits: JSON.stringify(node.messages).length,
+        transcriptCodeUnits: JSON.stringify(node.blocks).length,
+        contextCodeUnits: node.context?.summary.length ?? 0,
+    });
+}
+function emptyBounds() {
+    return Object.freeze({ messageCodeUnits: 0, transcriptCodeUnits: 0, contextCodeUnits: 0 });
+}
+function addBounds(left, right) {
+    return Object.freeze({
+        messageCodeUnits: left.messageCodeUnits + right.messageCodeUnits,
+        transcriptCodeUnits: left.transcriptCodeUnits + right.transcriptCodeUnits,
+        contextCodeUnits: left.contextCodeUnits + right.contextCodeUnits,
+    });
+}
+function replaceBounds(total, before, after) {
+    return Object.freeze({
+        messageCodeUnits: total.messageCodeUnits - before.messageCodeUnits + after.messageCodeUnits,
+        transcriptCodeUnits: total.transcriptCodeUnits - before.transcriptCodeUnits + after.transcriptCodeUnits,
+        contextCodeUnits: total.contextCodeUnits - before.contextCodeUnits + after.contextCodeUnits,
+    });
+}
+function assertContextPath(nodes, owner) {
+    const context = owner.context;
+    if (context === undefined)
+        return;
+    const boundary = context.throughNodeId === owner.id
+        ? owner
+        : nodes[context.throughNodeId - 1];
+    if (boundary === undefined || !validContextAnchor(context, boundary.messages.length)) {
+        throw new Error("turn context checkpoint is invalid");
+    }
+    let current = owner;
+    while (current !== undefined && current.id !== boundary.id) {
+        current = nodes[current.parentId - 1];
+    }
+    if (current === undefined)
+        throw new Error("turn context checkpoint is outside its branch");
 }
 function assertContextPaths(nodes, owners) {
     if (owners.length === 0)
@@ -288,3 +338,14 @@ function validNodeId(value) {
 function clone(value) {
     return structuredClone(value);
 }
+function deepFreeze(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return value;
+    seen.add(value);
+    if (!ArrayBuffer.isView(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child, seen);
+        Object.freeze(value);
+    }
+    return value;
+}

package/dist/credential-safety.js

@@ -1,8 +1,11 @@
 // The shell needs a useful process environment, not the application's secrets.
 import { credentialValues } from "./credentials.js";
 import { accountValues } from "./accounts.js";
+import { USER_STORE_LIMITS } from "./user-store.js";
 const REDACTED = "[credential redacted]";
 const MIN_HEURISTIC_SECRET_CHARS = 8;
+export const MAX_REDACTION_SECRETS = USER_STORE_LIMITS.credentialEntries;
+const MAX_REDACTION_SECRET_CODE_UNITS = USER_STORE_LIMITS.accountToken;
 const EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES = new Set([
     "ANTHROPIC_API_KEY",
     "OLLAMA_API_KEY",
@@ -27,11 +30,24 @@ export function shellEnvironment(source = process.env) {
 }
 /** Remove values Jecode recognizes as credentials before tool output leaves the shell boundary. */
 export function redactCredentials(text, source = process.env) {
-    return redact(text, secrets(source));
+    const known = secrets(source);
+    return known.saturated ? (text === "" ? "" : REDACTED) : redact(text, known.values);
 }
 /** Redact before bounded capture, retaining enough raw overlap for split values. */
 export function credentialRedactor(source = process.env) {
-    const values = secrets(source);
+    const known = secrets(source);
+    if (known.saturated)
+        return closedRedactor();
+    const values = known.values;
+    const candidates = new Map();
+    for (const value of values) {
+        const first = value[0];
+        const bucket = candidates.get(first);
+        if (bucket === undefined)
+            candidates.set(first, [value]);
+        else
+            bucket.push(value);
+    }
     const longest = Math.max(0, ...values.map((value) => value.length));
     let pending = "";
     return {
@@ -40,16 +56,17 @@ export function credentialRedactor(source = process.env) {
             const ready = [];
             let at = 0;
             while (at < combined.length) {
-                const rest = combined.slice(at);
+                const matching = candidates.get(combined[at]) ?? [];
+                const rest = matching.length === 0 ? "" : combined.slice(at);
                 // A complete shorter credential can also be the prefix of a longer
                 // one. Hold that ambiguous suffix until the next chunk proves which
                 // value arrived, otherwise the longer credential leaks its tail.
                 if (rest.length < longest &&
-                    values.some((value) => value.length > rest.length && value.startsWith(rest))) {
+                    matching.some((value) => value.length > rest.length && value.startsWith(rest))) {
                     pending = rest;
                     return ready.join("");
                 }
-                const complete = values.find((value) => combined.startsWith(value, at));
+                const complete = matching.find((value) => combined.startsWith(value, at));
                 if (complete !== undefined) {
                     ready.push(REDACTED);
                     at += complete.length;
@@ -68,6 +85,20 @@ export function credentialRedactor(source = process.env) {
         },
     };
 }
+function closedRedactor() {
+    let emitted = false;
+    return {
+        write(chunk) {
+            if (chunk === "" || emitted)
+                return "";
+            emitted = true;
+            return REDACTED;
+        },
+        end() {
+            return "";
+        },
+    };
+}
 function sensitiveEnvironmentName(name) {
     const normalized = name
         .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
@@ -79,16 +110,32 @@ function sensitiveEnvironmentName(name) {
         COMPACT_SENSITIVE_ENVIRONMENT_NAME.test(normalized));
 }
 function secrets(source) {
-    const values = new Set([...credentialValues(), ...accountValues()]);
+    const values = new Set();
+    let saturated = false;
+    const add = (value) => {
+        if (value === "" || values.has(value) || saturated)
+            return;
+        if (value.length > MAX_REDACTION_SECRET_CODE_UNITS ||
+            values.size >= MAX_REDACTION_SECRETS) {
+            saturated = true;
+            return;
+        }
+        values.add(value);
+    };
+    for (const value of [...credentialValues(), ...accountValues()])
+        add(value);
     for (const [name, value] of Object.entries(source)) {
-        if (value === undefined || value === "")
+        if (saturated || value === undefined || value === "")
             continue;
         const explicit = EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES.has(name.toUpperCase());
         if (explicit || (value.length >= MIN_HEURISTIC_SECRET_CHARS && sensitiveEnvironment(name, value))) {
-            values.add(value);
+            add(value);
         }
     }
-    return [...values].filter((value) => value !== "").sort((left, right) => right.length - left.length);
+    return {
+        values: [...values].sort((left, right) => right.length - left.length),
+        saturated,
+    };
 }
 function redact(text, values) {
     let redacted = text;