@sema-agent/server 7.79.1 → 7.79.3

package/dist/trace/redact.js

@@ -206,7 +206,6 @@ function forgetEscapedSeparatorTails() {
     escapedTailsValue = undefined;
 }
 const VALUE_ARM_STICKY = new Map();
-const VALUE_ARMS = new Set();
 const VALUE_ARM_BODIES = [];
 const valueArm = (prefixSrc, valueClass, min, evidence) => {
     const body = `${prefixSrc}${twoStrongAhead(valueClass)}${atLeast(valueClass, min)}`;
@@ -226,29 +225,145 @@ const valueArm = (prefixSrc, valueClass, min, evidence) => {
             }
         }
     })();
-    VALUE_ARMS.add(g);
     return g;
 };
 let anyValueArm;
 function anyValueArmRe() {
     return (anyValueArm ??= new RegExp(`(?:${VALUE_ARM_BODIES.join("|")})`, "y"));
 }
+const ARM_RANK = { structural: 0, keyword: 1, shape: 2, fragment: 3 };
+let poolSpanCount = 0;
+let poolArmCount = 0;
+let poolBoundaryArmCount = 0;
+let coveredPositions = 0;
+let headScreenHits = 0;
+let fullYCalls = 0;
+let forensicLevels = 0;
+let ssh2ScanBytes = 0;
+export function armPoolBudgetForTest() {
+    return { spanCount: poolSpanCount, coveredPositions, headScreenHits, fullYCalls, armCount: poolArmCount, boundaryArmCount: poolBoundaryArmCount, forensicLevels, ssh2ScanBytes };
+}
+export function resetArmPoolBudgetForTest() {
+    poolSpanCount = 0;
+    coveredPositions = 0;
+    headScreenHits = 0;
+    fullYCalls = 0;
+    forensicLevels = 0;
+    ssh2ScanBytes = 0;
+}
+const unitBit = (t, c) => (t[c >>> 5] >>> (c & 31)) & 1;
+let codeUnitDomain;
+const codeUnitMembersCache = new Map();
+function codeUnitMembers(unitSrc) {
+    let table = codeUnitMembersCache.get(unitSrc);
+    if (table === undefined) {
+        if (codeUnitDomain === undefined) {
+            const parts = [];
+            for (let c = 0; c < 0x10000; c++)
+                parts.push(String.fromCharCode(c));
+            codeUnitDomain = parts.join("");
+        }
+        table = new Uint32Array(0x10000 >>> 5);
+        const re = new RegExp(unitSrc, "g");
+        let members = 0;
+        for (let m = re.exec(codeUnitDomain); m !== null; m = re.exec(codeUnitDomain)) {
+            if (m[0].length !== 1)
+                throw new Error(`redact: /${unitSrc}/ is not a single-code-unit matcher`);
+            table[m.index >>> 5] = table[m.index >>> 5] | (1 << (m.index & 31));
+            members += 1;
+            re.lastIndex = m.index + 1;
+        }
+        if (members === 0)
+            throw new Error(`redact: /${unitSrc}/ matches no code unit — it cannot serve as a member set`);
+        codeUnitMembersCache.set(unitSrc, table);
+    }
+    return table;
+}
+function unitsDisjoint(a, b) {
+    const ta = codeUnitMembers(a);
+    const tb = codeUnitMembers(b);
+    for (let i = 0; i < ta.length; i++)
+        if ((ta[i] & tb[i]) !== 0)
+            return false;
+    return true;
+}
+function unionMembers(tables) {
+    const out = new Uint32Array(0x10000 >>> 5);
+    for (const t of tables) {
+        if (t === undefined)
+            return undefined;
+        for (let i = 0; i < out.length; i++)
+            out[i] = out[i] | t[i];
+    }
+    return out;
+}
 const HEAD_CLASS_ESCAPES = new Set(["d", "D", "w", "W", "s", "S"]);
 const HEAD_LITERAL_ESCAPES = new Set(["\\", "/", "-", ".", "+", "*", "?", "(", ")", "[", "]", "{", "}", "|", "^", "$"]);
+function assertWall(atoms, w, src) {
+    const wall = atoms[w];
+    const fail = (why) => {
+        throw new Error(`redact: head derivation cannot bound the unbounded head atom at ${w} in /${src}/ — ${why}`);
+    };
+    if (wall.unit === undefined)
+        fail("the wall is not a single-code-unit atom");
+    const wallUnit = wall.unit;
+    const firstUnit = atoms[0].unit;
+    for (let k = 0; k < w; k++) {
+        const a = atoms[k];
+        if (a.unit === undefined || a.unbounded)
+            fail(`the head atom at ${k} is not a bounded single-code-unit atom`);
+        if (!unitsDisjoint(a.unit, wallUnit))
+            fail(`the head atom at ${k} can hold the wall's own character`);
+        if (k > 0 && (firstUnit === undefined || !unitsDisjoint(a.unit, firstUnit)))
+            fail(`the head overlaps itself at ${k}`);
+    }
+    for (let k = w + 1; k < atoms.length; k++) {
+        const a = atoms[k];
+        if (a.unit === undefined || !unitsDisjoint(a.unit, wallUnit))
+            fail(`the atom at ${k} can hold the wall's own character`);
+    }
+}
 function headOfAtoms(atoms, src) {
-    const tail = atoms[atoms.length - 1];
-    if (tail === undefined || !tail.unbounded || tail.cls === undefined) {
-        throw new Error(`redact: arm-pool pattern /${src}/ must end in a greedy unbounded single-class value run`);
+    const tailForm = () => {
+        throw new Error(`redact: arm-pool pattern /${src}/ must end in a greedy unbounded single-class value run (optionally followed by a bounded literal tail run disjoint from it)`);
+    };
+    let vi = atoms.length - 1;
+    const last = atoms[vi];
+    if (last === undefined)
+        tailForm();
+    if (last.cls === undefined) {
+        const prev = atoms[vi - 1];
+        if (last.unit === undefined || prev === undefined || !prev.unbounded || prev.cls === undefined || !unitsDisjoint(last.unit, prev.cls))
+            tailForm();
+        vi -= 1;
     }
+    const value = atoms[vi];
+    if (value === undefined || !value.unbounded || value.cls === undefined)
+        tailForm();
+    const cls = value.cls;
     let pos = 0;
     let head = 0;
-    for (let k = 0; k < atoms.length - 1; k++) {
+    const parts = [];
+    for (let k = 0; k < vi; k++) {
         const a = atoms[k];
-        if (a.cls !== tail.cls)
+        if (a.unbounded) {
+            assertWall(atoms, k, src);
+            return { len: pos + 1, head: undefined, first: undefined };
+        }
+        parts.push(a.src);
+        if (a.cls !== cls)
             head = pos + a.len;
         pos += a.len;
     }
-    return head;
+    return { len: head, head: parts.length === 0 ? undefined : parts.join(""), first: firstOfAtoms(atoms.slice(0, vi)) };
+}
+function firstOfAtoms(atoms) {
+    for (const a of atoms) {
+        if (a.len === 0)
+            continue;
+        return a.first;
+    }
+    return undefined;
 }
 const HEAD_GROUP_OPEN = /^\((\?:|\?=|\?!|\?<=|\?<!)/;
 function parseHeadAlternative(src, from) {
@@ -261,6 +376,7 @@ function parseHeadAlternative(src, from) {
             break;
         if (closed)
             throw new Error(`redact: arm-pool pattern /${src}/ has trailing syntax after its value run`);
+        const atomFrom = i;
         let base;
         if (c === "(") {
             const open = HEAD_GROUP_OPEN.exec(src.slice(i));
@@ -278,7 +394,7 @@ function parseHeadAlternative(src, from) {
                 closed = true;
                 continue;
             }
-            base = { len: Math.max(...inner.alts.map((alt) => alt.reduce((n, a) => n + a.len, 0))), cls: undefined };
+            base = { len: Math.max(...inner.alts.map((alt) => alt.reduce((n, a) => n + a.len, 0))), cls: undefined, unit: undefined, first: unionMembers(inner.alts.map(firstOfAtoms)) };
         }
         else if (c === "[") {
             let k = i + 1;
@@ -286,7 +402,7 @@ function parseHeadAlternative(src, from) {
                 k += src[k] === "\\" ? 2 : 1;
             if (k >= src.length)
                 throw new Error(`redact: unterminated character class at ${i} in /${src}/`);
-            base = { len: 1, cls: src.slice(i, k + 1) };
+            base = { len: 1, cls: src.slice(i, k + 1), unit: src.slice(i, k + 1), first: codeUnitMembers(src.slice(i, k + 1)) };
             i = k + 1;
         }
         else if (c === "\\") {
@@ -294,9 +410,9 @@ function parseHeadAlternative(src, from) {
             if (e === undefined)
                 throw new Error(`redact: dangling escape at ${i} in /${src}/`);
             if (HEAD_CLASS_ESCAPES.has(e))
-                base = { len: 1, cls: `\\${e}` };
+                base = { len: 1, cls: `\\${e}`, unit: `\\${e}`, first: codeUnitMembers(`\\${e}`) };
             else if (HEAD_LITERAL_ESCAPES.has(e))
-                base = { len: 1, cls: undefined };
+                base = { len: 1, cls: undefined, unit: `\\${e}`, first: codeUnitMembers(`\\${e}`) };
             else
                 throw new Error(`redact: head derivation cannot bound escape \\${e} at ${i} in /${src}/`);
             i += 2;
@@ -305,16 +421,17 @@ function parseHeadAlternative(src, from) {
             throw new Error(`redact: head derivation cannot bound ${JSON.stringify(c)} at ${i} in /${src}/`);
         }
         else {
-            base = { len: 1, cls: undefined };
+            base = { len: 1, cls: undefined, unit: c, first: codeUnitMembers(c) };
             i += 1;
         }
-        let atom = { ...base, unbounded: false };
+        let atom = { ...base, unbounded: false, src: "" };
         const q = src[i];
         if (q === "*" || q === "+") {
-            atom = { ...base, unbounded: true };
+            atom = { ...base, unbounded: true, src: "" };
             i += 1;
         }
         else if (q === "?") {
+            atom = { ...base, unbounded: false, src: "", first: undefined };
             i += 1;
         }
         else if (q === "{") {
@@ -323,15 +440,14 @@ function parseHeadAlternative(src, from) {
                 throw new Error(`redact: head derivation cannot bound quantifier at ${i} in /${src}/`);
             const lo = Number(m[1]);
             const hi = m[2] === undefined ? lo : m[3] === "" ? -1 : Number(m[3]);
-            atom = hi < 0 ? { ...base, unbounded: true } : { len: base.len * hi, cls: base.cls, unbounded: false };
+            atom = hi < 0 ? { ...base, unbounded: true, src: "" } : { len: base.len * hi, cls: base.cls, unit: base.unit, unbounded: false, src: "", first: lo === 0 ? undefined : base.first };
             i += m[0].length;
         }
         if (src[i] === "?")
             throw new Error(`redact: head derivation cannot bound a lazy quantifier at ${i} in /${src}/`);
-        if (atom.unbounded)
-            closed = true;
+        const withSrc = { ...atom, src: src.slice(atomFrom, i) };
         for (const s of seqs)
-            s.push(atom);
+            s.push(withSrc);
     }
     return { seqs, next: i };
 }
@@ -348,39 +464,36 @@ function parseHeadAlternatives(src, from) {
     }
     return { alts, next: i };
 }
-function literalHeadLength(re) {
+function deriveLiteralHead(re) {
     if (/[uv]/.test(re.flags))
         throw new Error(`redact: head derivation does not support the u/v flags on /${re.source}/`);
     const src = re.source;
     const parsed = parseHeadAlternatives(src, 0);
     if (parsed.next !== src.length)
         throw new Error(`redact: head derivation stopped at ${parsed.next} in /${src}/`);
-    return Math.max(...parsed.alts.map((alt) => headOfAtoms(alt, src)));
-}
-function scanResumeAfterHit(start, end, head) {
-    return Math.max(start + 1, end - Math.max(head - 1, 0));
+    const per = parsed.alts.map((alt) => headOfAtoms(alt, src));
+    const heads = per.map((p) => p.head);
+    return {
+        len: Math.max(...per.map((p) => p.len)),
+        src: heads.some((h) => h === undefined) ? undefined : `(?:${heads.join("|")})`,
+        first: unionMembers(per.map((p) => p.first)),
+    };
 }
-function headWindowCandidates(at, maxHead) {
-    const out = [];
-    let last = -1;
-    for (const e of at) {
-        for (let p = Math.max(e - Math.max(maxHead - 1, 0), last + 1, 0); p <= e; p++) {
-            out.push({ p, back: e - p });
-            last = p;
-        }
-    }
-    return out;
+function scanResumeAfterHit(start, end, back) {
+    return Math.max(start + 1, end - back);
 }
-function collectRegexSpans(g, head, repl, order, text, out) {
+const spanOffset = (a, m) => (a.outside === 1 ? m[1].length : 0);
+function collectRegexSpans(a, text, out) {
+    const g = a.g;
     g.lastIndex = 0;
     for (let m = g.exec(text); m !== null; m = g.exec(text)) {
         const end = m.index + m[0].length;
-        out.push({ start: m.index, end, repl, order });
-        g.lastIndex = scanResumeAfterHit(m.index, end, head);
+        out.push({ start: m.index + spanOffset(a, m), end, repl: a.repl, rank: a.rank, order: a.order });
+        g.lastIndex = scanResumeAfterHit(m.index, end, a.back);
     }
 }
 function resolveSpanOverlaps(spans) {
-    spans.sort((a, b) => a.start - b.start || b.end - a.end || a.order - b.order);
+    spans.sort((a, b) => a.start - b.start || b.end - a.end || a.rank - b.rank || a.order - b.order);
     const kept = [];
     let covered = 0;
     for (const s of spans) {
@@ -403,10 +516,11 @@ function applySpans(text, spans) {
     parts.push(text.slice(copied));
     return { out: parts.join(""), count: spans.length };
 }
-function collectValueArmSpans(g, y, head, repl, order, text, out) {
+function collectValueArmSpans(arm, text, out) {
+    const { g, y, back, repl, rank, order } = arm;
     const tails = escapedSeparatorTails(text);
     if (tails === undefined) {
-        collectRegexSpans(g, head, repl, order, text, out);
+        collectRegexSpans(arm, text, out);
         return;
     }
     let pos = 0;
@@ -451,29 +565,32 @@ function collectValueArmSpans(g, y, head, repl, order, text, out) {
         }
         else
             break;
-        out.push({ start: idx, end, repl, order });
-        pos = scanResumeAfterHit(idx, end, head);
+        out.push({ start: idx, end, repl, rank, order });
+        pos = scanResumeAfterHit(idx, end, back);
     }
 }
-function collectStickySpans(y, head, repl, order, text, at, out) {
+function collectStickySpans(a, text, at, out) {
+    const { y, back, repl, rank, order } = a;
     let pos = 0;
-    for (const { p, back } of at) {
-        if (back >= head)
-            continue;
+    for (const p of at) {
         if (p < pos)
             continue;
         y.lastIndex = p;
+        fullYCalls += 1;
         const m = y.exec(text);
         if (m === null)
             continue;
         const end = p + m[0].length;
-        out.push({ start: p, end, repl, order });
-        pos = scanResumeAfterHit(p, end, head);
+        out.push({ start: p + spanOffset(a, m), end, repl, rank, order });
+        pos = scanResumeAfterHit(p, end, back);
     }
 }
 const WORD_SEGMENT_CLASS = "[A-Za-z0-9._~+/-]";
-const keywordArm = (keywordSrc, valueClass, min, tailSrc = "") => new RegExp(`(?:${keywordSrc}\\s+${atLeast(valueClass, min)}${tailSrc}` +
-    `|(?<!${WORD_SEGMENT_CLASS})${keywordSrc}(?:${twoStrongAhead(valueClass)}|${noConnectorAhead(valueClass)})${atLeast(valueClass, min)}${tailSrc})`, "g");
+const keywordArm = (keywordSrc, valueClass, min, tailSrc = "") => {
+    const re = new RegExp(`(?:${keywordSrc}\\s+${atLeast(valueClass, min)}${tailSrc}` +
+        `|(?<!${WORD_SEGMENT_CLASS})${keywordSrc}(?:${twoStrongAhead(valueClass)}|${noConnectorAhead(valueClass)})${atLeast(valueClass, min)}${tailSrc})`, "g");
+    return re;
+};
 const STRUCTURAL_SECRET_PATTERNS = [
     [/-----BEGIN(?:[^-](?:[^-](?:[^-]|-(?!-))*)?)?PRIVATE KEY(?: BLOCK)?-----[\s\S]{0,8192}?-----END(?:[^-](?:[^-](?:[^-]|-(?!-))*)?)?PRIVATE KEY(?: BLOCK)?-----/g, "«redacted:private-key»"],
     [/---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----[\s\S]{0,8192}?---- END SSH2 ENCRYPTED PRIVATE KEY ----/g, "«redacted:private-key»"],
@@ -518,6 +635,8 @@ function skipPemSeps(s, i, limit) {
     for (;;) {
         if (i >= limit)
             return i;
+        if (opaqueUnitEnd(i) >= 0)
+            return i;
         const c = s.charCodeAt(i);
         if (isSepCode(c)) {
             i += 1;
@@ -560,16 +679,16 @@ function pemInlineSepLen(s, i, limit) {
     return 0;
 }
 function probePemHeaderToken(s, p, limit) {
-    if (p >= limit || !isIdentStartCode(s.charCodeAt(p)))
+    if (p >= limit || opaqueUnitEnd(p) >= 0 || !isIdentStartCode(s.charCodeAt(p)))
         return -1;
     p += 1;
     let identLen = 1;
-    while (identLen < PEM_HEADER_IDENT_MAX && p < limit && isIdentCode(s.charCodeAt(p))) {
+    while (identLen < PEM_HEADER_IDENT_MAX && p < limit && opaqueUnitEnd(p) < 0 && isIdentCode(s.charCodeAt(p))) {
         p += 1;
         identLen += 1;
     }
     for (;;) {
-        if (p >= limit)
+        if (p >= limit || opaqueUnitEnd(p) >= 0)
             return -1;
         const c = s.charCodeAt(p);
         if (c === CH_SPACE || c === CH_TAB) {
@@ -601,6 +720,11 @@ function parsePemHeaderLine(s, i, limit, allowBare, json) {
     for (;;) {
         if (p >= limit)
             return setPemHdr(start, p, p, true);
+        const unit = opaqueUnitEnd(p);
+        if (unit >= 0) {
+            p = Math.min(unit, limit);
+            continue;
+        }
         const c = s.charCodeAt(p);
         if (c !== CH_CR && c !== CH_LF && c !== CH_SPACE && c !== CH_TAB && c !== CH_BACKSLASH && c !== CH_QUOTE) {
             p += 1;
@@ -626,6 +750,8 @@ function parsePemHeaderLine(s, i, limit, allowBare, json) {
         }
         let q = p;
         for (;;) {
+            if (opaqueUnitEnd(q) >= 0)
+                break;
             const b = pemLineBreakLen(s, q, limit);
             if (b === 1)
                 return setPemHdr(start, p, q + 1, false);
@@ -651,7 +777,7 @@ function parsePemBody(s, i, limit) {
     for (;;) {
         const q = skipPemSeps(s, p, limit);
         let r = q;
-        while (r < limit && isBase64Code(s.charCodeAt(r)))
+        while (r < limit && opaqueUnitEnd(r) < 0 && isBase64Code(s.charCodeAt(r)))
             r += 1;
         if (r - q < PEM_BODY_RUN_MIN)
             break;
@@ -664,13 +790,15 @@ function rightmostPemRunEnd(s, from, to) {
     let best = -1;
     let runStart = -1;
     for (let p = from; p <= to; p++) {
-        if (p < to && s.charCodeAt(p) === CH_LAQUO) {
-            const tokenEnd = redactionTokenEndAt(s, p, to);
-            if (tokenEnd > 0) {
+        if (p < to) {
+            const unit = opaqueUnitEnd(p);
+            if (unit > 0) {
                 if (runStart >= 0 && p - runStart >= PEM_BODY_RUN_MIN)
                     best = p;
                 runStart = -1;
-                p = tokenEnd - 1;
+                if (unit > to)
+                    return best;
+                p = unit - 1;
                 continue;
             }
         }
@@ -717,15 +845,74 @@ function findPemFence(text, from) {
         if (close < 0)
             return undefined;
         from = labelFrom;
+        if (inOpaqueUnit(fence))
+            continue;
         if (!isPemFenceLabel(text, labelFrom, close))
             continue;
         return { fence, after: close + PEM_FENCE_CLOSE.length };
     }
 }
-function redactPemFragments(text, json) {
-    let count = 0;
-    let out;
-    let copied = 0;
+const SSH2_FENCE_OPEN = "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----";
+const SSH2_FENCE_CLOSE = "---- END SSH2 ENCRYPTED PRIVATE KEY ----";
+const SSH2_BODY_MAX = 8192;
+function unitCountWithin(from, to, max) {
+    if (to - from <= max)
+        return true;
+    const st = scanEvidence.starts;
+    if (st.length === 0)
+        return false;
+    const k = firstCredentialSpanFrom(scanEvidence, from);
+    if (k >= st.length || st[k] >= to)
+        return false;
+    let n = 0;
+    for (let p = from; p < to;) {
+        if (n > max)
+            return false;
+        const unit = opaqueUnitEnd(p);
+        p = unit > 0 && unit <= to ? unit : p + 1;
+        n += 1;
+    }
+    return n <= max;
+}
+function collectSsh2FenceSpans(text, span) {
+    let cachedFrom = 0;
+    let cachedAt;
+    const nextClose = (from) => {
+        if (cachedAt !== undefined && cachedFrom <= from && (cachedAt < 0 || cachedAt >= from))
+            return cachedAt;
+        let p = text.indexOf(SSH2_FENCE_CLOSE, from);
+        ssh2ScanBytes += (p < 0 ? text.length : p) - from;
+        while (p >= 0 && inOpaqueUnit(p)) {
+            const q = text.indexOf(SSH2_FENCE_CLOSE, p + 1);
+            ssh2ScanBytes += (q < 0 ? text.length : q) - (p + 1);
+            p = q;
+        }
+        cachedFrom = from;
+        cachedAt = p;
+        return p;
+    };
+    for (let from = 0;;) {
+        const fence = text.indexOf(SSH2_FENCE_OPEN, from);
+        if (fence < 0)
+            return;
+        if (inOpaqueUnit(fence)) {
+            from = fence + 1;
+            continue;
+        }
+        const bodyFrom = fence + SSH2_FENCE_OPEN.length;
+        const close = nextClose(bodyFrom);
+        if (close < 0)
+            return;
+        if (!unitCountWithin(bodyFrom, close, SSH2_BODY_MAX)) {
+            from = fence + 1;
+            continue;
+        }
+        const end = close + SSH2_FENCE_CLOSE.length;
+        span(fence, end);
+        from = scanResumeAfterHit(fence, end, SSH2_FENCE_OPEN.length);
+    }
+}
+function collectPemFragmentSpans(text, json, span) {
     let cur = findPemFence(text, 0);
     let inherited = false;
     while (cur !== undefined) {
@@ -752,29 +939,24 @@ function redactPemFragments(text, json) {
         let bodyEnd = parsePemBody(text, pos, limit);
         if (bodyEnd < 0)
             bodyEnd = rightmost;
-        if (bodyEnd >= 0) {
-            out ??= [];
-            out.push(text.slice(copied, cur.fence), PEM_FRAGMENT_TOKEN);
-            copied = bodyEnd;
-            count += 1;
-        }
+        if (bodyEnd >= 0)
+            span(cur.fence, bodyEnd);
         cur = next;
     }
-    if (out === undefined)
-        return { out: text, count: 0 };
-    out.push(text.slice(copied));
-    return { out: out.join(""), count };
 }
-function redactHeadlessPpkBodies(text) {
+function collectHeadlessPpkSpans(text, span) {
     const KEY = "Private-Lines: ";
     const n = text.length;
     const isB64 = (c) => (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 43 || c === 47 || c === 61;
-    const skipHs = (i) => { while (i < n && (text.charCodeAt(i) === 32 || text.charCodeAt(i) === 9))
+    const b64At = (i) => opaqueUnitEnd(i) < 0 && isB64(text.charCodeAt(i));
+    const skipHs = (i) => { while (i < n && opaqueUnitEnd(i) < 0 && (text.charCodeAt(i) === 32 || text.charCodeAt(i) === 9))
         i += 1; return i; };
     const skipNewlines = (i) => {
         let q = skipHs(i);
         let seen = false;
         for (;;) {
+            if (opaqueUnitEnd(q) >= 0)
+                break;
             let any = false;
             if (text.charCodeAt(q) === 13) {
                 q += 1;
@@ -806,6 +988,8 @@ function redactHeadlessPpkBodies(text) {
         return seen ? q : -1;
     };
     const escapedNewlineLen = (i) => {
+        if (opaqueUnitEnd(i) >= 0)
+            return 0;
         let k = i;
         while (k < n && text.charCodeAt(k) === 92)
             k += 1;
@@ -818,20 +1002,23 @@ function redactHeadlessPpkBodies(text) {
         const b = skipHs(i);
         if (b >= n)
             return true;
+        if (opaqueUnitEnd(b) >= 0)
+            return false;
         const c = text.charCodeAt(b);
         return c === 10 || c === 13 || c === 34 || escapedNewlineLen(b) > 0;
     };
-    let out = "";
-    let last = 0;
-    let count = 0;
     let search = 0;
     for (;;) {
         const at = text.indexOf(KEY, search);
         if (at === -1)
             break;
+        if (inOpaqueUnit(at)) {
+            search = at + KEY.length;
+            continue;
+        }
         let p = at + KEY.length;
         const d0 = p;
-        while (p < n && text.charCodeAt(p) >= 48 && text.charCodeAt(p) <= 57)
+        while (p < n && opaqueUnitEnd(p) < 0 && text.charCodeAt(p) >= 48 && text.charCodeAt(p) <= 57)
             p += 1;
         if (p === d0) {
             search = at + KEY.length;
@@ -844,15 +1031,15 @@ function redactHeadlessPpkBodies(text) {
             if (q0 === -1)
                 break;
             let q = q0;
-            const mk = text.charCodeAt(q);
+            const mk = opaqueUnitEnd(q) < 0 ? text.charCodeAt(q) : -1;
             if (mk === 43 || mk === 45)
                 q = skipHs(q + 1);
             let r = q;
-            while (r < n && isB64(text.charCodeAt(r)))
+            while (r < n && b64At(r))
                 r += 1;
             if (r - q < 4) {
                 r = q0;
-                while (r < n && isB64(text.charCodeAt(r)))
+                while (r < n && b64At(r))
                     r += 1;
                 if (r - q0 < 4)
                     break;
@@ -866,12 +1053,9 @@ function redactHeadlessPpkBodies(text) {
             search = p;
             continue;
         }
-        out += text.slice(last, at) + HEADLESS_PPK_TOKEN;
-        last = end;
+        span(at, end);
         search = end;
-        count += 1;
     }
-    return count === 0 ? { out: text, count: 0 } : { out: out + text.slice(last), count };
 }
 const FRAGMENT_SECRET_PATTERNS = [
     [valueArm("sk-", "[A-Za-z0-9_-]", 6, "needs-left-boundary"), "«redacted:key:partial»"],
@@ -885,21 +1069,12 @@ const FRAGMENT_SECRET_PATTERNS = [
 ];
 const REDACTION_TOKENS = new Set([...FULL_ARM_PATTERNS.map(([, r]) => r), PEM_FRAGMENT_TOKEN, ...FRAGMENT_SECRET_PATTERNS.map(([, r]) => r)]
     .flatMap((r) => r.match(/«[^»]*»/g) ?? []));
-const REDACTION_TOKEN_MAX = Math.max(...[...REDACTION_TOKENS].map((t) => t.length));
 {
     const closed = new RegExp(`^${REDACTION_TOKEN_RE_SRC}$`);
     for (const t of REDACTION_TOKENS)
         if (!closed.test(t))
             throw new Error(`redact: token ${t} is outside the closed form ${REDACTION_TOKEN_RE_SRC}`);
 }
-function redactionTokenEndAt(s, p, limit) {
-    const max = Math.min(limit, p + REDACTION_TOKEN_MAX);
-    for (let e = p + 2; e <= max; e++) {
-        if (s.charCodeAt(e - 1) === 187)
-            return REDACTION_TOKENS.has(s.slice(p, e)) ? e : 0;
-    }
-    return 0;
-}
 const labelOfToken = (token) => token.replace(/[«»]/g, "").replace(/^redacted:/, "");
 const FRAGMENT_ARM_TOKENS = new Set(FRAGMENT_SECRET_PATTERNS.map(([, repl]) => repl));
 {
@@ -916,42 +1091,118 @@ const FRAGMENT_ARM_TOKENS = new Set(FRAGMENT_SECRET_PATTERNS.map(([, repl]) => r
 }
 const armOfToken = (repl) => (FRAGMENT_ARM_TOKENS.has(repl) ? "fragment" : "full");
 const NO_HITS = [];
-const singleHit = (label, arm, r) => r.count > 0 ? { out: r.out, hits: [{ label, count: r.count, arm }] } : { out: r.out, hits: NO_HITS };
-const regexRule = ([re, repl]) => {
-    const groupCount = (new RegExp(`${re.source}|`).exec("")?.length ?? 1) - 1;
-    const refs = [...repl.matchAll(/\$(.)/g)].map(([, d]) => d ?? "");
-    for (const d of refs) {
-        if (!/^[1-9]$/.test(d) || Number(d) > groupCount)
-            throw new Error(`redact: replacement ${JSON.stringify(repl)} uses unsupported ref $${d}`);
-    }
-    const expand = refs.length === 0 ? undefined : (args) => repl.replace(/\$([1-9])/g, (_, d) => args[Number(d)] ?? "");
-    const arm = armOfToken(repl);
-    if (VALUE_ARMS.has(re) || arm === "fragment")
-        throw new Error(`redact: rule ${JSON.stringify(repl)} belongs in the arm pool, not a per-arm section`);
-    const label = labelOfToken(repl);
-    const applyOnce = (text, wantCount) => {
-        if (!wantCount)
-            return { out: text.replace(re, repl), count: 0 };
-        let n = 0;
-        const out = text.replace(re, (...args) => {
-            n += 1;
-            return expand === undefined ? repl : expand(args);
-        });
-        return { out, count: n };
-    };
-    return { run: (text, wantCount) => singleHit(label, arm, applyOnce(text, wantCount)) };
-};
 const URL_USERINFO_PATTERN = (() => {
     const row = FULL_ARM_PATTERNS.find(([, repl]) => repl.endsWith("»@"));
     if (row === undefined)
         throw new Error("redact: URL-userinfo rule missing from FULL_ARM_PATTERNS");
     return row;
 })();
+const SSH2_FENCE_PATTERN = (() => {
+    const row = FULL_ARM_PATTERNS.find(([re]) => re.source.startsWith(SSH2_FENCE_OPEN));
+    if (row === undefined)
+        throw new Error("redact: SSH2 fence rule missing from FULL_ARM_PATTERNS");
+    return row;
+})();
 const isRegexSpace = (c) => c === 32 || (c >= 9 && c <= 13) || c === 0xa0 || c === 0x1680 || (c >= 0x2000 && c <= 0x200a) || c === 0x2028 || c === 0x2029 || c === 0x202f || c === 0x205f || c === 0x3000 || c === 0xfeff;
 const isLineTerminator = (c) => c === 10 || c === 13 || c === 0x2028 || c === 0x2029;
+const TOKEN_UNIT_Y = new RegExp(REDACTION_TOKEN_RE_SRC, "y");
+function tokenUnitEnd(text, p) {
+    TOKEN_UNIT_Y.lastIndex = p;
+    return TOKEN_UNIT_Y.test(text) ? TOKEN_UNIT_Y.lastIndex : -1;
+}
+const NO_CREDENTIAL_SPANS = { starts: new Int32Array(0), ends: new Int32Array(0) };
+function credentialSpans(text, spans, withSpans) {
+    const iv = withSpans ? spans.map((sp) => [sp.start, sp.end]) : [];
+    for (let i = text.indexOf("«"); i >= 0; i = text.indexOf("«", i + 1)) {
+        const e = tokenUnitEnd(text, i);
+        if (e > 0) {
+            iv.push([i, e]);
+            i = e - 1;
+        }
+    }
+    if (iv.length === 0)
+        return NO_CREDENTIAL_SPANS;
+    iv.sort((a, b) => a[0] - b[0]);
+    const starts = new Int32Array(iv.length);
+    const ends = new Int32Array(iv.length);
+    let k = 0;
+    let [cs, ce] = iv[0];
+    for (let j = 1; j < iv.length; j++) {
+        const [s2, e2] = iv[j];
+        if (s2 <= ce)
+            ce = Math.max(ce, e2);
+        else {
+            starts[k] = cs;
+            ends[k] = ce;
+            k += 1;
+            cs = s2;
+            ce = e2;
+        }
+    }
+    starts[k] = cs;
+    ends[k] = ce;
+    k += 1;
+    return { starts: starts.subarray(0, k), ends: ends.subarray(0, k) };
+}
+function sameCredentialSpans(a, b) {
+    if (a.starts.length !== b.starts.length)
+        return false;
+    for (let i = 0; i < a.starts.length; i++)
+        if (a.starts[i] !== b.starts[i] || a.ends[i] !== b.ends[i])
+            return false;
+    return true;
+}
+function firstCredentialSpanFrom(cs, from) {
+    let lo = 0;
+    let hi = cs.starts.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (cs.starts[mid] < from)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+function credentialSpansCover(cs, from, to) {
+    let k = firstCredentialSpanFrom(cs, from + 1) - 1;
+    if (k < 0)
+        k = 0;
+    return k < cs.starts.length && cs.starts[k] <= from && cs.ends[k] >= to;
+}
+let scanEvidence = NO_CREDENTIAL_SPANS;
+let scanEvidenceCursor = 0;
+function setScanEvidence(cs) {
+    scanEvidence = cs;
+    scanEvidenceCursor = 0;
+}
+function inOpaqueUnit(p) {
+    const st = scanEvidence.starts;
+    if (st.length === 0)
+        return false;
+    const k = firstCredentialSpanFrom(scanEvidence, p) - 1;
+    return k >= 0 && st[k] < p && scanEvidence.ends[k] > p;
+}
+function opaqueUnitEnd(p) {
+    const st = scanEvidence.starts;
+    if (st.length === 0)
+        return -1;
+    let k = scanEvidenceCursor;
+    while (k < st.length && st[k] < p)
+        k += 1;
+    while (k > 0 && st[k - 1] >= p)
+        k -= 1;
+    scanEvidenceCursor = k;
+    return k < st.length && st[k] === p ? scanEvidence.ends[k] : -1;
+}
 function scanUserinfoRun(text, i, kind, json) {
     const n = text.length;
     while (i < n) {
+        const unit = opaqueUnitEnd(i);
+        if (unit >= 0) {
+            i = unit;
+            continue;
+        }
         const c = text.charCodeAt(i);
         if (json && c === 92) {
             if (i + 1 < n && !isLineTerminator(text.charCodeAt(i + 1))) {
@@ -980,48 +1231,19 @@ function scanUserinfoRun(text, i, kind, json) {
     }
     return i;
 }
-const REDACTION_TOKEN_Y = new RegExp(REDACTION_TOKEN_RE_SRC, "y");
-const SHAPE_STICKY = SHAPE_SECRET_PATTERNS.map(([re]) => new RegExp(re.source, "y"));
-function keyShapedUsernameEnd(text, p) {
-    for (const re of SHAPE_STICKY) {
-        re.lastIndex = p;
-        if (re.test(text))
-            return re.lastIndex;
-    }
-    return -1;
-}
 function matchUserinfoAt(text, p, json) {
-    REDACTION_TOKEN_Y.lastIndex = p;
-    const tokEnd = REDACTION_TOKEN_Y.test(text) ? REDACTION_TOKEN_Y.lastIndex : -1;
-    const afterTok = tokEnd >= 0 ? text.charCodeAt(tokEnd) : -1;
-    if (afterTok === 64)
+    const userEnd = scanUserinfoRun(text, p, "plain-user", json);
+    if (text.charCodeAt(userEnd) !== 58)
         return null;
-    let userEnd = -1;
-    let kind;
-    if (afterTok === 58) {
-        userEnd = tokEnd;
-        kind = "token-pass";
-    }
-    else if ((() => { const e = keyShapedUsernameEnd(text, p); return e >= 0 && text.charCodeAt(e) === 58 ? ((userEnd = e), true) : false; })()) {
-        kind = "token-pass";
-    }
-    else {
-        userEnd = scanUserinfoRun(text, p, "plain-user", json);
-        if (text.charCodeAt(userEnd) !== 58)
-            return null;
-        kind = "plain-pass";
-    }
-    const passEnd = scanUserinfoRun(text, userEnd + 1, kind, json);
+    const keyId = userEnd > p && credentialSpansCover(scanEvidence, p, userEnd);
+    const passEnd = scanUserinfoRun(text, userEnd + 1, keyId ? "token-pass" : "plain-pass", json);
     if (passEnd === userEnd + 1 || text.charCodeAt(passEnd) !== 64)
         return null;
     return [userEnd, passEnd + 1];
 }
-function redactUrlUserinfo(text, json) {
-    const [head, repl] = URL_USERINFO_PATTERN;
+function collectUrlUserinfoSpans(text, json, span) {
+    const head = URL_USERINFO_PATTERN[0];
     head.lastIndex = 0;
-    let out = "";
-    let last = 0;
-    let count = 0;
     for (let m = head.exec(text); m !== null; m = head.exec(text)) {
         const colon = m.index;
         const hit = matchUserinfoAt(text, colon + 3, json);
@@ -1029,18 +1251,14 @@ function redactUrlUserinfo(text, json) {
             head.lastIndex = colon + 1;
             continue;
         }
-        const user = text.slice(colon, hit[0]);
-        out += text.slice(last, colon) + repl.replace(/\$1/g, () => user);
-        last = hit[1];
+        span(hit[0], hit[1]);
         head.lastIndex = hit[1];
-        count += 1;
     }
-    return count === 0 ? { out: text, count: 0 } : { out: out + text.slice(last), count };
 }
 let ppkScanBytes = 0;
 export function ppkScanBytesForTest() { return ppkScanBytes; }
 export function resetPpkScanBytesForTest() { ppkScanBytes = 0; }
-function redactPpkContainers(text, record) {
+function collectPpkContainerSpans(text, record, span) {
     const HEAD = "PuTTY-User-Key-File-";
     const MAC = "Private-MAC: ";
     const HASH = "Private-Hash: ";
@@ -1059,7 +1277,7 @@ function redactPpkContainers(text, record) {
     const isVersionedHead = (at) => {
         let p = at + HEAD.length;
         const start = p;
-        while (p < text.length) {
+        while (p < text.length && opaqueUnitEnd(p) < 0) {
             const c = text.charCodeAt(p);
             if (c >= 48 && c <= 57)
                 p += 1;
@@ -1070,13 +1288,13 @@ function redactPpkContainers(text, record) {
     };
     const nextVersionedHead = (from) => {
         let p = find(HEAD, from);
-        while (p !== Number.POSITIVE_INFINITY && !isVersionedHead(p))
+        while (p !== Number.POSITIVE_INFINITY && (inOpaqueUnit(p) || !isVersionedHead(p)))
             p = find(HEAD, p + HEAD.length);
         return p;
     };
     const hexRunEnd = (from) => {
         let e = from;
-        while (e < text.length) {
+        while (e < text.length && opaqueUnitEnd(e) < 0) {
             const c = text.charCodeAt(e);
             if ((c >= 48 && c <= 57) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70))
                 e += 1;
@@ -1085,9 +1303,6 @@ function redactPpkContainers(text, record) {
         }
         return e;
     };
-    let out = "";
-    let last = 0;
-    let count = 0;
     let at = nextVersionedHead(0);
     while (at !== Number.POSITIVE_INFINITY) {
         let pos = at + HEAD.length + 1;
@@ -1114,6 +1329,10 @@ function redactPpkContainers(text, record) {
             let gapBlank = true;
             if (limit !== Number.POSITIVE_INFINITY) {
                 for (let i = hexEnd; i < limit; i++) {
+                    if (opaqueUnitEnd(i) >= 0) {
+                        gapBlank = false;
+                        break;
+                    }
                     const c = text.charCodeAt(i);
                     if (c !== 32 && c !== 10 && c !== 13 && c !== 9) {
                         gapBlank = false;
@@ -1127,103 +1346,206 @@ function redactPpkContainers(text, record) {
         }
         if (ateToEnd && record)
             recordFailOpen("server.redact.ppk-eat-to-end", `from=${at} len=${text.length}`);
-        out += text.slice(last, at) + PPK_CONTAINER_TOKEN;
-        last = end;
-        count += 1;
+        span(at, end);
         at = end >= text.length ? Number.POSITIVE_INFINITY : nextVersionedHead(end);
     }
-    return count === 0 ? { out: text, count: 0 } : { out: out + text.slice(last), count };
 }
-const URL_USERINFO_LABEL = labelOfToken(URL_USERINFO_PATTERN[1]);
-const urlUserinfoRule = { run: (text, _wantCount, json) => singleHit(URL_USERINFO_LABEL, "full", redactUrlUserinfo(text, json)) };
-const armPoolRule = (() => {
-    const arms = [...SHAPE_SECRET_PATTERNS, ...FRAGMENT_SECRET_PATTERNS].map(([re, repl], order) => {
-        if (/\$./.test(repl))
-            throw new Error(`redact: arm-pool replacement ${JSON.stringify(repl)} must not use $N refs`);
+const armPool = (() => {
+    const spanRepl = (token) => {
+        const body = token.startsWith("$1") ? token.slice(2) : token;
+        if (/\$./.test(body))
+            throw new Error(`redact: arm-pool replacement ${JSON.stringify(token)} may only use a leading $1 (the run kept outside the span)`);
+        return body;
+    };
+    const literalAnchorHead = (re) => {
+        const src = re.source;
+        let i = src.startsWith("(") && !src.startsWith("(?") ? 1 : 0;
+        let out = "";
+        for (; i < src.length; i++) {
+            const c = src[i];
+            if (c === "\\") {
+                const e = src[i + 1];
+                if (e === undefined || !HEAD_LITERAL_ESCAPES.has(e))
+                    break;
+                if ("*+?{".includes(src[i + 2] ?? ""))
+                    break;
+                out += src.slice(i, i + 2);
+                i += 1;
+                continue;
+            }
+            if ("([{|).^$*+?".includes(c))
+                break;
+            if ("*+?{".includes(src[i + 1] ?? ""))
+                break;
+            out += c;
+        }
+        if (out.length === 0)
+            throw new Error(`redact: structural arm /${src}/ has no literal anchor head — its same-arm rewind amount cannot be derived`);
+        return out;
+    };
+    const regexMember = ([re, token], rank, order, structural) => {
+        const repl = spanRepl(token);
+        const outside = token.startsWith("$1") ? 1 : 0;
         const y = VALUE_ARM_STICKY.get(re);
-        const head = literalHeadLength(re);
-        if (y !== undefined && head === 0)
-            throw new Error(`redact: boundary arm /${re.source}/ has a zero-length structural head — the head-window screen would skip every candidate position`);
-        return { g: re, y, head, repl, order };
-    });
-    const boundaryArms = arms.flatMap((a) => (a.y === undefined ? [] : [{ y: a.y, head: a.head, repl: a.repl, order: a.order }]));
-    const maxBoundaryHead = Math.max(1, ...boundaryArms.map((a) => a.head));
-    return {
-        run: (text, wantCount) => {
-            const spans = [];
-            for (const a of arms) {
-                if (a.y === undefined)
-                    collectRegexSpans(a.g, a.head, a.repl, a.order, text, spans);
-                else
-                    collectValueArmSpans(a.g, a.y, a.head, a.repl, a.order, text, spans);
+        let back;
+        let headSrc;
+        let headFirst;
+        if (structural) {
+            back = literalAnchorHead(re).length;
+            headSrc = undefined;
+            headFirst = undefined;
+        }
+        else {
+            const d = deriveLiteralHead(re);
+            back = Math.max(d.len - 1, 0);
+            headSrc = d.src;
+            headFirst = d.first;
+            if (y !== undefined && (d.len === 0 || headSrc === undefined || headFirst === undefined)) {
+                throw new Error(`redact: boundary arm /${re.source}/ has a zero-length structural head — the bounded head screen would admit every candidate position`);
             }
-            const tried = new Set();
-            const freshEnds = (from) => {
-                const at = [];
-                for (let k = from; k < spans.length; k++) {
-                    const e = spans[k].end;
-                    if (tried.has(e))
+        }
+        if (y !== undefined && outside === 1)
+            throw new Error(`redact: value arm /${re.source}/ cannot carry an outside-span $1 prefix`);
+        const arm = { g: re, y, back, headSrc, headFirst, repl, rank, order, outside };
+        const boundary = y === undefined || headSrc === undefined || headFirst === undefined ? undefined : { ...arm, y, headSrc, headFirst };
+        return {
+            token,
+            rank,
+            order,
+            phase: 1,
+            collect: boundary === undefined
+                ? (text, _json, _observe, out) => collectRegexSpans(arm, text, out)
+                : (text, _json, _observe, out) => collectValueArmSpans(boundary, text, out),
+            retry: boundary === undefined ? undefined : (text, at, out) => collectStickySpans(boundary, text, at, out),
+            headSrc: boundary === undefined ? undefined : headSrc,
+            headFirst: boundary === undefined ? undefined : headFirst,
+        };
+    };
+    const scannerMember = (token, order, phase, scan) => {
+        const repl = spanRepl(token);
+        return {
+            token,
+            rank: ARM_RANK.structural,
+            order,
+            phase,
+            collect: (text, json, observe, out) => scan(text, json, observe, (start, end) => out.push({ start, end, repl, rank: ARM_RANK.structural, order })),
+            retry: undefined,
+            headSrc: undefined,
+            headFirst: undefined,
+        };
+    };
+    const members = [];
+    for (const row of STRUCTURAL_SECRET_PATTERNS) {
+        const order = members.length;
+        members.push(row === URL_USERINFO_PATTERN
+            ? scannerMember(row[1], order, 2, (text, json, _observe, span) => collectUrlUserinfoSpans(text, json, span))
+            : row === SSH2_FENCE_PATTERN
+                ? scannerMember(row[1], order, 2, (text, _json, _observe, span) => collectSsh2FenceSpans(text, span))
+                : regexMember(row, ARM_RANK.structural, order, true));
+    }
+    members.push(scannerMember(PPK_CONTAINER_TOKEN, members.length, 2, (text, _json, observe, span) => collectPpkContainerSpans(text, observe, span)));
+    members.push(scannerMember(PEM_FRAGMENT_TOKEN, members.length, 2, (text, json, _observe, span) => collectPemFragmentSpans(text, json, span)));
+    members.push(scannerMember(HEADLESS_PPK_TOKEN, members.length, 2, (text, _json, _observe, span) => collectHeadlessPpkSpans(text, span)));
+    for (const row of KEYWORD_SECRET_PATTERNS)
+        members.push(regexMember(row, ARM_RANK.keyword, members.length, false));
+    for (const row of SHAPE_SECRET_PATTERNS)
+        members.push(regexMember(row, ARM_RANK.shape, members.length, false));
+    for (const row of FRAGMENT_SECRET_PATTERNS)
+        members.push(regexMember(row, ARM_RANK.fragment, members.length, false));
+    const retryMembers = members.filter((m) => m.retry !== undefined);
+    const phase1 = members.filter((m) => m.phase === 1);
+    const phase2 = members.filter((m) => m.phase === 2);
+    const headScreen = new RegExp(`(?:${retryMembers.map((m) => m.headSrc).join("|")})`, "y");
+    const headFirstUnit = unionMembers(retryMembers.map((m) => m.headFirst)) ?? new Uint32Array(0x10000 >>> 5).fill(0xffffffff);
+    poolArmCount = members.length;
+    poolBoundaryArmCount = retryMembers.length;
+    return (text, wantCount, json, observe) => {
+        const spans = [];
+        let tried;
+        const freshCovered = (from) => {
+            const at = [];
+            const seen = (tried ??= new Uint8Array(text.length + 1));
+            for (let k = from; k < spans.length; k++) {
+                const s = spans[k];
+                for (let p = s.start; p <= s.end; p++) {
+                    if (seen[p] === 1)
+                        continue;
+                    seen[p] = 1;
+                    coveredPositions += 1;
+                    if (unitBit(headFirstUnit, text.charCodeAt(p)) !== 1)
+                        continue;
+                    headScreen.lastIndex = p;
+                    if (headScreen.exec(text) === null)
                         continue;
-                    tried.add(e);
-                    at.push(e);
+                    at.push(p);
                 }
-                return at.sort((x, y) => x - y);
-            };
-            for (let at = freshEnds(0); at.length > 0;) {
+            }
+            headScreenHits += at.length;
+            return at.sort((x, y) => x - y);
+        };
+        const closeCoveragePositions = (from) => {
+            if (retryMembers.length === 0 || spans.length === from)
+                return;
+            for (let at = freshCovered(from); at.length > 0;) {
                 const before = spans.length;
-                const cand = headWindowCandidates(at, maxBoundaryHead);
-                for (const a of boundaryArms)
-                    collectStickySpans(a.y, a.head, a.repl, a.order, text, cand, spans);
-                at = freshEnds(before);
+                for (const m of retryMembers)
+                    m.retry(text, at, spans);
+                at = freshCovered(before);
             }
-            const kept = resolveSpanOverlaps(spans);
-            const out = applySpans(text, kept).out;
-            if (!wantCount || kept.length === 0)
-                return { out, hits: NO_HITS };
-            const strong = spans.filter((sp) => armOfToken(sp.repl) === "full").sort((a, b) => a.start - b.start);
-            const byArmedToken = new Map();
-            let si = 0;
-            let strongMaxEnd = -1;
-            for (const sp of kept) {
-                while (si < strong.length && strong[si].start < sp.end) {
-                    strongMaxEnd = Math.max(strongMaxEnd, strong[si].end);
-                    si += 1;
-                }
-                const arm = strongMaxEnd > sp.start ? "full" : armOfToken(sp.repl);
-                const key = `${sp.repl}\u0000${arm}`;
-                const cur = byArmedToken.get(key);
-                if (cur === undefined)
-                    byArmedToken.set(key, { token: sp.repl, arm, count: 1 });
-                else
-                    cur.count += 1;
+        };
+        setScanEvidence(NO_CREDENTIAL_SPANS);
+        for (const m of phase1)
+            m.collect(text, json, observe, spans);
+        closeCoveragePositions(0);
+        if (phase2.length > 0) {
+            let evidence = credentialSpans(text, spans, false);
+            for (let level = 0;; level += 1) {
+                const before = spans.length;
+                setScanEvidence(evidence);
+                for (const m of phase2)
+                    m.collect(text, json, observe && level === 0, spans);
+                closeCoveragePositions(before);
+                forensicLevels += 1;
+                const next = credentialSpans(text, spans, true);
+                if (sameCredentialSpans(next, evidence))
+                    break;
+                evidence = next;
             }
-            return { out, hits: [...byArmedToken.values()].map(({ token, arm, count }) => ({ label: labelOfToken(token), count, arm })) };
-        },
+            setScanEvidence(NO_CREDENTIAL_SPANS);
+        }
+        poolSpanCount += spans.length;
+        const kept = resolveSpanOverlaps(spans);
+        const out = applySpans(text, kept).out;
+        if (!wantCount || kept.length === 0)
+            return { out, hits: NO_HITS };
+        const tokenOf = (sp) => members[sp.order].token;
+        const strong = spans.filter((sp) => armOfToken(tokenOf(sp)) === "full").sort((a, b) => a.start - b.start);
+        const byArmedToken = new Map();
+        let si = 0;
+        let strongMaxEnd = -1;
+        for (const sp of kept) {
+            while (si < strong.length && strong[si].start < sp.end) {
+                strongMaxEnd = Math.max(strongMaxEnd, strong[si].end);
+                si += 1;
+            }
+            const token = tokenOf(sp);
+            const arm = strongMaxEnd > sp.start ? "full" : armOfToken(token);
+            const key = `${token}\u0000${arm}`;
+            const cur = byArmedToken.get(key);
+            if (cur === undefined)
+                byArmedToken.set(key, { token, arm, count: 1 });
+            else
+                cur.count += 1;
+        }
+        return { out, hits: [...byArmedToken.values()].map(({ token, arm, count }) => ({ label: labelOfToken(token), count, arm })) };
     };
 })();
-const SECRET_RULES = [
-    ...STRUCTURAL_SECRET_PATTERNS.map((p) => (p === URL_USERINFO_PATTERN ? urlUserinfoRule : regexRule(p))),
-    { run: (text, _wantCount, _json, observe) => singleHit(labelOfToken(PPK_CONTAINER_TOKEN), armOfToken(PPK_CONTAINER_TOKEN), redactPpkContainers(text, observe)) },
-    { run: (text, _wantCount, json) => singleHit(labelOfToken(PEM_FRAGMENT_TOKEN), armOfToken(PEM_FRAGMENT_TOKEN), redactPemFragments(text, json)) },
-    { run: (text) => singleHit(labelOfToken(HEADLESS_PPK_TOKEN), armOfToken(HEADLESS_PPK_TOKEN), redactHeadlessPpkBodies(text)) },
-    ...KEYWORD_SECRET_PATTERNS.map((p) => regexRule(p)),
-    armPoolRule,
-    { run: (text, _wantCount, json) => ({ out: redactUrlUserinfo(text, json).out, hits: NO_HITS }) },
-];
 let onRedaction;
 export function setRedactionObserver(fn) {
     onRedaction = fn;
 }
 function applyRules(text, wantCount, json, observe) {
-    let out = text;
-    const hits = [];
-    for (const rule of SECRET_RULES) {
-        const r = rule.run(out, wantCount, json, observe);
-        out = r.out;
-        if (wantCount && r.hits.length > 0)
-            hits.push(...r.hits);
-    }
-    return { out, hits };
+    return armPool(text, wantCount, json, observe);
 }
 function reportHits(hits) {
     if (onRedaction === undefined)