@zackbart/connecta 0.37.0 → 0.38.0

package/dist/sent-secrets.js

@@ -5,7 +5,7 @@ import { Effect } from "effect";
 import { classificationCode, ConnectorCallError } from "./errors.js";
 import { credentialUrlViews } from "./credential-url.js";
 import { RequestScope, requestOwner } from "./runtime/request-scope.js";
-import { viewSecrets, wrapViewCredentials } from "./runtime/call.js";
+import { viewSecrets } from "./runtime/call.js";
 import { visitPrivateCallArguments } from "./argument-redaction.js";
 import { keptErrorName, redactedCopyOf } from "./redaction-identity.js";
 import { REDACTED } from "./redaction-marker.js";
@@ -127,6 +127,12 @@ const TEXT = 0;
 const NUMBER = 1;
 const BINARY = 2;
 const BYTES = 3;
+// A typed binary's joined numbers are withheld together, including on an error.
+const NUMBERS = 4;
+// A changed numeric diagnostic is absent from the error's text projection.
+const ERROR_NUMBER = 5;
+const numeric = (kind) => kind === NUMBER || kind === NUMBERS || kind === ERROR_NUMBER;
+const replacement = (kind) => (kind === BINARY || kind === ERROR_NUMBER ? "" : REDACTED);
 /** An accessor met while looking up an inherited field: never invoked. */
 const WITHHELD_ACCESSOR = Symbol("accessor");
 /** The engine's own getters for what a typed array, DataView or ArrayBuffer holds, so no
@@ -682,7 +688,7 @@ function headerSpace(text, at) {
 }
 /**
  * The echo's spans with the value of every sensitive header line (`headerLine`'s names) added,
- * read on the text before the echo is replaced (#703). An echoed private value can take part of a
+ * read on the text before the echo is replaced. An echoed private value can take part of a
  * header's name, its `:`, or a credential prefix such as `Bearer `, so the line cannot be read
  * after replacement; read here, the whole value goes, every cookie pair and any short tail with
  * it. A line that is not a sensitive header keeps its text. One forward pass; nothing is kept.
@@ -1310,6 +1316,24 @@ export class SentSecrets {
     text(value) {
         return this.idle() ? value : this.project(value, this.scan(true)).value;
     }
+    /** An SDK response body, checked after it has been fully read so late registrations
+     * still apply. An idle set leaves the original serialization untouched. */
+    serializedAgentOutput(body, json) {
+        if (this.idle())
+            return body;
+        if (json) {
+            // Structured redaction joins text blocks, including secrets split across them.
+            try {
+                return JSON.stringify(redactAgentOutput(this, JSON.parse(body)));
+            }
+            catch {
+                /* Non-JSON diagnostics still pass through the text boundary. */
+            }
+        }
+        // A second serialized pass over parsed JSON would mistake a blob's encoding
+        // for credential bytes. Only non-JSON bodies take this text path.
+        return redactAgentOutput(this, body);
+    }
     /** A plain-data snapshot of `value` with every match removed: own enumerable data properties
      * (an error's own fields, non-enumerable ones included), read once each. Accessors are never
      * invoked, except an error's stack and the accessors its class defines, read once into the
@@ -1566,10 +1590,8 @@ export class SentSecrets {
      * charged to the call's budget, and a part it cannot pay for is withheld. A `bounded` lane is
      * text cut short, which also loses an unfinished tail. Nothing else matches a string that is
      * returned: the matching steps below are called only from here. */
-    checked(parts, kinds, scan, bounded = false) {
-        const safe = this.safeParts(parts, kinds, scan, bounded);
-        this.encodedLeaves(parts, kinds, safe, scan);
-        return safe;
+    checked(parts, kinds, scan, bounded = false, normalize) {
+        return this.safeParts(parts, kinds, scan, bounded, normalize);
     }
     /** Cursor claims: the whole text and its encoding under the boundary's rules, then every
      * string in the JSON under payload rules. Keys and numbers are Connecta's own names and
@@ -1690,7 +1712,7 @@ export class SentSecrets {
             // Binary and bytes any match changed are withheld whole already.
             const kind = kinds[index];
             const text = safe[index];
-            if (kind === NUMBER || text === REDACTED || this.memo.get(text) === true)
+            if (numeric(kind) || text === REDACTED || this.memo.get(text) === true)
                 continue;
             if ((!scan.payload && this.memo.has(text)) || (kind !== TEXT && text !== parts[index]))
                 continue;
@@ -1755,11 +1777,63 @@ export class SentSecrets {
                     safe[pairLeaves[pair]] = REDACTED;
         }
     }
-    /** The parts' joined text, matched once, with each part's replacement. A tiny or short
-     * private value equal to a whole part withholds it. A number or a serialized container that
-     * a match touches is withheld whole. A bounded lane also loses an unfinished tail, and is
-     * withheld whole when the set could not tell where one begins. */
-    safeParts(parts, kinds, scan, bounded) {
+    /** Check replacements as returned, including their placeholder seams. Numbers touched by
+     * the first scan get one chance beside the replaced strings; every later hit withholds its
+     * entire part. Each changing round therefore removes at least one remaining part. Unchanged
+     * lanes pay for no retry. Large lanes recheck changed parts and the seams touching them; an
+     * unaffordable check withholds every part it read and all original retention candidates. */
+    settleParts(parts, safe, scan, numbers = [], leafByLeaf = false, kinds, normalize) {
+        let touched = new Set(parts.flatMap((part, index) => (part !== safe[index] ? [index] : [])));
+        if (!touched.size)
+            return safe;
+        const lane = [...safe];
+        for (const index of numbers)
+            lane[index] = parts[index];
+        normalize?.(lane);
+        while (touched.size) {
+            // Pay for round bookkeeping even when no registered matcher could scan (for
+            // example, an oversized private registration governed only by withholdRuns).
+            if (!spend(scan, lane.length)) {
+                const withheld = lane.map((part, index) => part && replacement(kinds?.[index]));
+                normalize?.(withheld);
+                return withheld;
+            }
+            let checked;
+            const recheck = { parts: touched, complete: true };
+            const matches = leafByLeaf ? undefined : this.spansOf(lane.join(""), scan, scan.payload);
+            if (matches && !matches.deep)
+                checked = replaceParts(lane, matches.spans);
+            else
+                checked = this.leafByLeaf(lane, scan, undefined, recheck);
+            const limit = this.limit(scan);
+            if (limit < Infinity)
+                checked = withholdRuns(lane, checked, limit);
+            if (!recheck.complete)
+                for (const index of numbers)
+                    if (checked[index] === parts[index])
+                        checked[index] = replacement(kinds?.[index]);
+            normalize?.(checked);
+            const next = new Set();
+            for (let index = 0; index < lane.length; index++) {
+                if (checked[index] === lane[index] || (lane[index] === REDACTED && checked[index] !== ""))
+                    continue;
+                const withheld = replacement(kinds?.[index]);
+                // Whole-field groups project one marker and empty remaining parts.
+                const value = checked[index] === "" ? "" : withheld;
+                if (lane[index] === value)
+                    continue;
+                lane[index] = value;
+                next.add(index);
+            }
+            touched = next;
+        }
+        return lane;
+    }
+    /** The parts' joined text, with each part's replacement. A touched number is checked again
+     * after string replacement before withholding it whole. Tiny or short whole private values,
+     * deep matches and unchecked runs still withhold changed numbers whole. A bounded lane also
+     * loses an unfinished tail, and withholds every touched number without a second check. */
+    safeParts(parts, kinds, scan, bounded, normalize) {
         if (!parts.length)
             return parts;
         const text = parts.join("");
@@ -1769,29 +1843,63 @@ export class SentSecrets {
             return parts.map((part) => part && REDACTED);
         if (bounded)
             this.openSpans(text, matches.spans);
-        let safe = matches ? replaceParts(parts, matches.spans) : this.leafByLeaf(parts, scan);
+        const numbers = [];
+        let safe = matches ? replaceParts(parts, matches.spans) : this.leafByLeaf(parts, scan, kinds, undefined, numbers);
+        if (matches && !bounded && !matches.deep)
+            for (let index = 0; index < parts.length; index++)
+                if (numeric(kinds[index]) && safe[index] !== parts[index])
+                    numbers.push(index);
         if (matches?.deep)
             safe = safe.map((next, index) => (parts[index].includes("\\") ? REDACTED : next));
+        const whole = new Set();
         if (scan.payload && this.smallForms)
-            safe = safe.map((next, index) => (this.whole(parts[index]) ? REDACTED : next));
+            safe = safe.map((next, index) => {
+                // Typed numeric groups checked their individual whole values while walking.
+                if (kinds[index] === NUMBERS || !this.whole(parts[index]))
+                    return next;
+                whole.add(index);
+                return REDACTED;
+            });
         const limit = this.limit(scan);
         if (limit < Infinity)
             safe = withholdRuns(parts, safe, limit);
-        return safe.map((next, index) => (next !== parts[index] && kinds[index] === NUMBER ? REDACTED : next));
+        safe = safe.map((next, index) => (next !== parts[index] && numeric(kinds[index]) ? REDACTED : next));
+        this.encodedLeaves(parts, kinds, safe, scan);
+        // Declared binary leaves as the checked encoding of the marker, not its partial text.
+        let marker;
+        safe = safe.map((next, index) => {
+            if (next === parts[index] || kinds[index] !== BINARY)
+                return next;
+            const encoded = btoa(REDACTED);
+            marker ??= this.checked([encoded], [TEXT], scan)[0] === encoded ? encoded : "";
+            return marker;
+        });
+        safe = safe.map((next, index) => (next !== parts[index] && kinds[index] === ERROR_NUMBER ? "" : next));
+        normalize?.(safe);
+        return this.settleParts(parts, safe, scan, numbers.filter((index) => !whole.has(index) && limit === Infinity), !matches, kinds, normalize);
     }
     /** Leaves too large to match joined within the work budget: each is matched alone, in order,
      * and one that does not fit is withheld without spending what a smaller one needs. A run
      * crossing from one kept leaf into the next, through any short leaves between them, is then
      * matched SEAM_UNITS deep on each side of the seam. */
-    leafByLeaf(parts, scan) {
-        const spans = parts.map((part) => {
+    leafByLeaf(parts, scan, kinds, recheck, candidates) {
+        const spans = parts.map((part, index) => {
+            // Only changed parts and their seams need checking on a retry. Kept neighbours
+            // remain exactly as returned, even when their full text would not fit again.
+            if (recheck && !recheck.parts.has(index))
+                return [];
             const matches = this.spansOf(part, scan, scan.payload);
+            if (recheck && (!matches || matches.deep))
+                recheck.complete = false;
             return !matches || (matches.deep && part.includes("\\")) ? undefined : matches.spans;
         });
         let pieces = [];
         const seam = () => {
             const text = pieces.map((piece) => piece.text).join("");
-            const matches = pieces.length > 1 ? this.spansOf(text, scan, scan.payload) : { spans: [], deep: false };
+            const needed = pieces.length > 1 && (!recheck || pieces.some((piece) => recheck.parts.has(piece.index)));
+            const matches = needed ? this.spansOf(text, scan, scan.payload) : { spans: [], deep: false };
+            if (recheck && (!matches || matches.deep))
+                recheck.complete = false;
             const ranges = matches ? merged(matches.spans) : [];
             let offset = 0;
             for (const piece of pieces) {
@@ -1806,7 +1914,9 @@ export class SentSecrets {
             pieces = [];
         };
         parts.forEach((part, index) => {
-            if (!spans[index])
+            // A failed retry, or a marker already introduced while walking, still
+            // contains this part in the returned lane. Keep its unchecked seams.
+            if (!spans[index] && !recheck && part !== REDACTED)
                 return seam();
             if (part.length <= 2 * SEAM_UNITS)
                 return void pieces.push({ index, start: 0, text: part });
@@ -1815,10 +1925,21 @@ export class SentSecrets {
             pieces.push({ index, start: part.length - SEAM_UNITS, text: part.slice(-SEAM_UNITS) });
         });
         seam();
-        return parts.map((part, index) => {
+        const safe = parts.map((part, index) => {
             const own = spans[index];
             return !own ? part && REDACTED : own.length ? replace(part, own) : part;
         });
+        const numbers = kinds
+            ? kinds.flatMap((kind, index) => numeric(kind) && spans[index]?.length && safe[index] !== parts[index] ? [index] : [])
+            : [];
+        if (candidates) {
+            for (const index of numbers)
+                candidates.push(index);
+            return safe;
+        }
+        return kinds
+            ? this.settleParts(parts, safe.map((next, index) => (next !== parts[index] && numeric(kinds[index]) ? REDACTED : next)), scan, numbers, true, kinds)
+            : safe;
     }
     /** Serialized JSON whose keys, syntax and leaves together hold a K-unit run of a form: one
      * spanning tokens, which no leaf holds alone, withholds the whole text. A run inside one
@@ -1891,10 +2012,12 @@ export class SentSecrets {
         const active = new Set();
         // Keys and scalars repeat across rows; each is checked once per call.
         const seen = { keys: new Map(), scalars: new Map() };
-        // Errors' unregistered names, as walked: a copy whose name changed holds the placeholder.
+        // An error name may contain parsed JSON. Any change collapses all of its
+        // projected leaves to one placeholder before the surrounding lane settles.
         const named = [];
-        // Typed binary: where its copy was put, and the leaves its numbers and bytes span.
-        const binaries = [];
+        // Non-byte typed arrays have an alternate numeric projection, in the same slots as
+        // their returned bytes. Neither representation can interrupt the other's neighbours.
+        const elements = new Map();
         // The accessors each prototype's chain defines, found once per call.
         const chains = new Map();
         let changed = false;
@@ -1903,7 +2026,8 @@ export class SentSecrets {
             if (owner >= 0)
                 nested[owner].dirty = true;
         };
-        const withheld = (owner) => {
+        const withheld = (frame, slot, owner) => {
+            leaf(REDACTED, TEXT, frame, slot, owner);
             touch(owner);
             return REDACTED;
         };
@@ -2004,8 +2128,9 @@ export class SentSecrets {
                 if (level < MAX_DECODE_LEVELS && /^\s*["[{]/.test(item) && spend(scan, item.length)) {
                     const parsed = parse(item);
                     if (parsed) {
-                        const entry = { frame, slot, json: undefined, owner, crossing: false, dirty: false };
-                        entry.crossing = this.spansTokens(item, scan);
+                        if (this.spansTokens(item, scan))
+                            return withheld(frame, slot, owner);
+                        const entry = { frame, slot, json: undefined, owner, dirty: false };
                         const index = nested.push(entry) - 1;
                         // Parsed JSON is this walk's own, so it is written in place.
                         const holder = { target: entry, shared: false, parent: undefined, slot: "json" };
@@ -2017,25 +2142,25 @@ export class SentSecrets {
                 return item;
             }
             if (typeof item === "number" || typeof item === "bigint") {
-                leaf(String(item), NUMBER, frame, slot, owner);
+                leaf(String(item), frame.target instanceof Error ? ERROR_NUMBER : NUMBER, frame, slot, owner);
                 return item;
             }
             if (typeof item === "boolean" || item === null)
-                return check(seen.scalars, String(item), NUMBER) === String(item) ? item : withheld(owner);
+                return check(seen.scalars, String(item), NUMBER) === String(item) ? item : withheld(frame, slot, owner);
             // A function carries no data, and every exit's serializer would call a toJSON it holds; a
             // symbol carries none either. Both are withheld.
             if (typeof item === "function" || typeof item === "symbol")
-                return withheld(owner);
+                return withheld(frame, slot, owner);
             if (typeof item !== "object")
                 return item;
             if (active.has(item) || depth > MAX_WALK_DEPTH)
-                return withheld(owner);
+                return withheld(frame, slot, owner);
             active.add(item);
             try {
                 return container(item, frame, slot, depth, level, owner, owned);
             }
             catch {
-                return withheld(owner); // A proxy trap or a toJSON that threw.
+                return withheld(frame, slot, owner); // A proxy trap or a toJSON that threw.
             }
             finally {
                 active.delete(item);
@@ -2063,24 +2188,36 @@ export class SentSecrets {
                 leaf(text, BINARY, frame, slot, owner);
             return text;
         };
-        /** Typed binary as the fresh Uint8Array of its bytes. Its leaves are the numbers JSON shows
-         * for it and for its copy, each element's and each byte's, and its bytes; a match in any
-         * withholds it whole, as does a size past the node budget. */
-        const typed = ({ bytes, elements }, frame, slot, owner) => {
-            const numbers = elements ? new elements(bytes.buffer) : undefined;
-            if (!fits(bytes.length + (numbers?.length ?? 0) + 1) || !spend(scan, Math.ceil(bytes.length / 8)))
-                return withheld(owner);
-            // The leaves write nowhere: the copy's slot is settled once they are checked.
-            const sink = { target: [], shared: false, parent: undefined, slot };
-            const start = parts.length;
-            if (numbers)
-                for (let index = 0; index < numbers.length; index++)
-                    leaf(String(numbers[index]), NUMBER, sink, index, owner);
-            for (let index = 0; index < bytes.length; index++)
-                leaf(DECIMAL[bytes[index]], NUMBER, sink, index, owner);
-            leaf(latin1(bytes), BYTES, sink, 0, owner);
-            binaries.push([frame, slot, owner, start, parts.length]);
-            return bytes;
+        /** Typed binary is one whole-withheld numeric part: its byte numbers are adjacent to
+         * neighbours in the returned lane, and original elements substitute in a separate lane.
+         * Individual numeric whole-value matches and the raw byte view are also checked. */
+        const typed = ({ bytes, elements: constructor }, frame, slot, owner) => {
+            const numbers = constructor ? new constructor(bytes.buffer) : undefined;
+            let clean = fits(bytes.length + (numbers?.length ?? 0) + 1) && spend(scan, Math.ceil(bytes.length / 8));
+            const decimal = (values) => {
+                const text = [];
+                for (let index = 0; index < values.length; index++) {
+                    const number = values === bytes ? DECIMAL[bytes[index]] : String(values[index]);
+                    if (scan.payload && this.smallForms && this.whole(number))
+                        clean = false;
+                    text.push(number);
+                }
+                return text.join("");
+            };
+            // Refuse oversize arrays before building their numeric projection.
+            if (!clean) {
+                return withheld(frame, slot, owner);
+            }
+            const text = decimal(bytes);
+            const original = numbers ? decimal(numbers) : undefined;
+            const binary = latin1(bytes);
+            clean &&= this.checked([binary], [BYTES], scan)[0] === binary;
+            if (clean && original !== undefined)
+                elements.set(parts.length, original);
+            leaf(clean ? text : REDACTED, NUMBERS, frame, slot, owner);
+            if (!clean)
+                touch(owner);
+            return clean ? bytes : REDACTED;
         };
         const container = (item, frame, slot, depth, level, owner, owned) => {
             const error = item instanceof Error;
@@ -2094,7 +2231,7 @@ export class SentSecrets {
                 // What serialization would read: a toJSON result, checked in place of the container.
                 const toJSON = inherited(item, "toJSON", WITHHELD_ACCESSOR);
                 if (toJSON === WITHHELD_ACCESSOR)
-                    return withheld(owner);
+                    return withheld(frame, slot, owner);
                 if (typeof toJSON === "function") {
                     const result = toJSON.call(item, String(slot));
                     if (result !== null && typeof result === "object")
@@ -2111,7 +2248,7 @@ export class SentSecrets {
         const list = (item, frame, slot, depth, level, owner, owned) => {
             const length = item.length;
             if (!fits(length))
-                return withheld(owner);
+                return withheld(frame, slot, owner);
             const own = walked(frame, item, slot, owned);
             for (let index = 0; index < length; index++) {
                 const descriptor = Object.getOwnPropertyDescriptor(item, index);
@@ -2120,7 +2257,7 @@ export class SentSecrets {
                     // and copied in, an accessor is withheld unread, and nothing leaves the hole as it is.
                     const found = owned ? undefined : inherited(item, String(index), WITHHELD_ACCESSOR);
                     if (found === WITHHELD_ACCESSOR)
-                        replace(own, index, REDACTED, owner);
+                        replace(own, index, withheld(own, index, owner), owner);
                     else if (found !== undefined) {
                         replaced.push([own, index, found]);
                         const next = visit(found, own, index, depth + 1, level, owner, owned);
@@ -2130,7 +2267,7 @@ export class SentSecrets {
                     continue;
                 }
                 if (!("value" in descriptor)) {
-                    replace(own, index, REDACTED, owner);
+                    replace(own, index, withheld(own, index, owner), owner);
                     continue;
                 }
                 const next = visit(descriptor.value, own, index, depth + 1, level, owner, owned);
@@ -2147,7 +2284,7 @@ export class SentSecrets {
         const record = (item, error, frame, slot, depth, level, owner, owned) => {
             const names = Object.getOwnPropertyNames(item);
             if (!fits(names.length))
-                return withheld(owner);
+                return withheld(frame, slot, owner);
             const prototype = Object.getPrototypeOf(item);
             let plain = owned ||
                 (!error &&
@@ -2244,9 +2381,20 @@ export class SentSecrets {
                 else if (typeof value === "string" && binaryField(field, key))
                     next = declared(value, target, name, owner);
                 else {
+                    const start = parts.length;
+                    const nestedStart = nested.length;
                     next = visit(value, target, name, depth + 1, level, owner, owned);
-                    if (error && key === "name" && typeof value === "string" && target === own)
-                        named.push([out, name, value]);
+                    if (error && key === "name" && typeof value === "string" && target === own) {
+                        if (parts.length === start)
+                            leaf("", TEXT, target, name, owner);
+                        named.push({
+                            copy: out,
+                            slot: name,
+                            start,
+                            end: parts.length,
+                            withheld: next !== value || nested.slice(nestedStart).some((entry) => entry.dirty),
+                        });
+                    }
                 }
                 if (target !== own)
                     continue;
@@ -2262,7 +2410,25 @@ export class SentSecrets {
         };
         const root = { target: { value: undefined }, shared: false, parent: undefined, slot: "value" };
         root.target["value"] = visit(value, root, "value", 0, 0, -1, false);
-        const safe = this.checked(parts, kinds, scan);
+        const normalize = named.length
+            ? (lane) => {
+                for (const entry of named) {
+                    for (let index = entry.start; !entry.withheld && index < entry.end; index++)
+                        if (lane[index] !== parts[index])
+                            entry.withheld = true;
+                    if (entry.withheld)
+                        for (let index = entry.start; index < entry.end; index++)
+                            lane[index] = index === entry.start ? REDACTED : "";
+                }
+            }
+            : undefined;
+        let lane = parts;
+        if (elements.size) {
+            const original = parts.map((part, index) => elements.get(index) ?? part);
+            const checked = this.checked(original, kinds, scan, false, normalize);
+            lane = checked.map((part, index) => (part === original[index] ? parts[index] : part));
+        }
+        const safe = this.checked(lane, kinds, scan, false, normalize);
         // Structure first, then the leaves inside it and typed binary, then nested JSON from the
         // innermost out.
         // A slot replaced by a toJSON result walked there takes the copy that result already got,
@@ -2273,7 +2439,6 @@ export class SentSecrets {
         }
         for (const frame of copied)
             writable(frame);
-        let marker;
         for (let index = 0; index < parts.length; index++) {
             const next = safe[index];
             const kind = kinds[index];
@@ -2283,34 +2448,20 @@ export class SentSecrets {
                 continue;
             }
             const holder = writable(frames[index]);
-            // Declared binary is withheld as the encoded marker, itself checked; a typed number on an
-            // error is dropped rather than turned into text.
-            if (kind === BINARY) {
-                const encoded = btoa(REDACTED);
-                marker ??= this.checked([encoded], [BINARY], scan)[0] === encoded ? encoded : "";
-            }
-            put(holder, slots[index], kind === BINARY ? marker : kind === NUMBER && holder instanceof Error ? undefined : next);
+            // A typed number on an error is dropped rather than turned into text.
+            put(holder, slots[index], kind === ERROR_NUMBER ? undefined : next);
             touch(owners[index]);
         }
-        for (const [frame, slot, owner, start, end] of binaries) {
-            let clean = true;
-            for (let index = start; clean && index < end; index++)
-                clean = safe[index] === parts[index];
-            if (clean)
-                continue;
-            put(writable(frame), slot, REDACTED);
-            touch(owner);
-        }
         for (let index = nested.length - 1; index >= 0; index--) {
             const entry = nested[index];
-            if (!entry.crossing && !entry.dirty)
+            if (!entry.dirty)
                 continue;
-            put(writable(entry.frame), entry.slot, entry.crossing ? REDACTED : JSON.stringify(entry.json));
+            put(writable(entry.frame), entry.slot, JSON.stringify(entry.json));
             touch(entry.owner);
         }
-        for (const [copy, slot, name] of named)
-            if (copy[slot] !== name)
-                put(copy, slot, REDACTED);
+        for (const entry of named)
+            if (entry.withheld)
+                put(entry.copy, entry.slot, REDACTED);
         return { value: root.target["value"], changed };
     }
 }
@@ -2361,9 +2512,6 @@ export function registerCredentialValues(secrets, values) {
             secrets.add(value);
     }
 }
-export function trackCredentialReads(ctx) {
-    wrapViewCredentials(ctx);
-}
 /** A connector's result or error as it enters: every connector's credentials and the
  * request's private arguments, under payload rules. */
 export function redactSentSecrets(ctx, value) {
@@ -2379,9 +2527,7 @@ export function requestSentSecrets(ctx) {
  * extracted from. Redact it whole first: a cut through an echoed form can leave a remnant
  * shorter than any fragment the output boundary matches, and a normalized number or
  * extracted substring may no longer hold the form at all. */
-export function redactBeforeCut(ctx, value) {
-    return requestSentSecrets(ctx).redact(value);
-}
+export const redactBeforeCut = redactSentSecrets;
 /** Base64, or base64url with `url`, of bytes or UTF-8 text Connecta returns to an agent: a
  * download, an attachment, a REST body, a page cursor. Every such encoding goes through here,
  * since no later pass reads through an encoding the output does not declare: the content is

package/dist/server.js

@@ -35,7 +35,7 @@ export function createFetchHandler(opts) {
             // Which sandbox, not how it is tuned: `connecta doctor` reports the
             // executor it just exercised rather than assuming one, and a
             // deployment whose executor identifies as nothing omits the key
-            // instead of inviting a guess (#368).
+            // instead of inviting a guess.
             ...(opts.executorName !== undefined ? { executor: { name: opts.executorName } } : {}),
             admission: {
                 policy: "global-fifo",
@@ -64,7 +64,7 @@ export function createFetchHandler(opts) {
         const defer = runtimeContext ? runtimeContext.waitUntil.bind(runtimeContext) : undefined;
         const originRefusal = routeMcp.rejectOrigin(request);
         if (originRefusal) {
-            return Effect.succeed(withSecurityHeaders(originRefusal, url, path));
+            return Effect.succeed(withSecurityHeaders(originRefusal, url));
         }
         // Container and orchestrator probes reach /health over plain HTTP on
         // loopback, where no proxy has set X-Forwarded-Proto. Redirecting them to
@@ -87,7 +87,7 @@ export function createFetchHandler(opts) {
             return Effect.succeed(withSecurityHeaders(new Response(null, {
                 status: 308,
                 headers: { Location: target.toString() },
-            }), url, path));
+            }), url));
         }
         const context = {
             request,
@@ -98,7 +98,7 @@ export function createFetchHandler(opts) {
             defer,
             runtimeContext,
         };
-        return Effect.map(route(context), (response) => withSecurityHeaders(response, url, path));
+        return Effect.map(route(context), (response) => withSecurityHeaders(response, url));
     });
     return function fetch(request, runtimeContext) {
         return runEdge(serve(request, runtimeContext), { signal: request.signal });