@sema-agent/server 7.79.1 → 7.79.2

package/dist/trace/redact.js

@@ -206,7 +206,7 @@ function forgetEscapedSeparatorTails() {
     escapedTailsValue = undefined;
 }
 const VALUE_ARM_STICKY = new Map();
-const VALUE_ARMS = new Set();
+const POOL_ONLY_ARMS = new Set();
 const VALUE_ARM_BODIES = [];
 const valueArm = (prefixSrc, valueClass, min, evidence) => {
     const body = `${prefixSrc}${twoStrongAhead(valueClass)}${atLeast(valueClass, min)}`;
@@ -226,29 +226,142 @@ const valueArm = (prefixSrc, valueClass, min, evidence) => {
             }
         }
     })();
-    VALUE_ARMS.add(g);
+    POOL_ONLY_ARMS.add(g);
     return g;
 };
 let anyValueArm;
 function anyValueArmRe() {
     return (anyValueArm ??= new RegExp(`(?:${VALUE_ARM_BODIES.join("|")})`, "y"));
 }
+const ARM_RANK = { keyword: 1, shape: 2, fragment: 3 };
+let poolSpanCount = 0;
+let poolArmCount = 0;
+let poolBoundaryArmCount = 0;
+let coveredPositions = 0;
+let headScreenHits = 0;
+let fullYCalls = 0;
+export function armPoolBudgetForTest() {
+    return { spanCount: poolSpanCount, coveredPositions, headScreenHits, fullYCalls, armCount: poolArmCount, boundaryArmCount: poolBoundaryArmCount };
+}
+export function resetArmPoolBudgetForTest() {
+    poolSpanCount = 0;
+    coveredPositions = 0;
+    headScreenHits = 0;
+    fullYCalls = 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 +374,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 +392,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 +400,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 +408,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 +419,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 +438,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 +462,35 @@ 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)));
+    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 scanResumeAfterHit(start, end, head) {
     return Math.max(start + 1, end - Math.max(head - 1, 0));
 }
-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 collectRegexSpans(g, head, repl, order, text, out) {
+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, end, repl: a.repl, rank: a.rank, order: a.order });
+        g.lastIndex = scanResumeAfterHit(m.index, end, a.head);
     }
 }
 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 +513,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, head, 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 +562,33 @@ function collectValueArmSpans(g, y, head, repl, order, text, out) {
         }
         else
             break;
-        out.push({ start: idx, end, repl, order });
+        out.push({ start: idx, end, repl, rank, order });
         pos = scanResumeAfterHit(idx, end, head);
     }
 }
-function collectStickySpans(y, head, repl, order, text, at, out) {
+function collectStickySpans(a, text, at, out) {
+    const { y, head, 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 });
+        out.push({ start: p, end, repl, rank, order });
         pos = scanResumeAfterHit(p, end, head);
     }
 }
 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");
+    POOL_ONLY_ARMS.add(re);
+    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»"],
@@ -926,7 +1041,7 @@ const regexRule = ([re, repl]) => {
     }
     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")
+    if (POOL_ONLY_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) => {
@@ -1137,45 +1252,63 @@ function redactPpkContainers(text, record) {
 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) => {
+    const arms = [
+        ...KEYWORD_SECRET_PATTERNS.map((row) => [row, ARM_RANK.keyword]),
+        ...SHAPE_SECRET_PATTERNS.map((row) => [row, ARM_RANK.shape]),
+        ...FRAGMENT_SECRET_PATTERNS.map((row) => [row, ARM_RANK.fragment]),
+    ].map(([[re, repl], rank], order) => {
         if (/\$./.test(repl))
             throw new Error(`redact: arm-pool replacement ${JSON.stringify(repl)} must not use $N refs`);
         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 head = deriveLiteralHead(re);
+        if (y !== undefined && (head.len === 0 || head.src === undefined || head.first === undefined)) {
+            throw new Error(`redact: boundary arm /${re.source}/ has a zero-length structural head — the bounded head screen would admit every candidate position`);
+        }
+        return { g: re, y, head: head.len, headSrc: head.src, headFirst: head.first, repl, rank, 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));
+    const boundaryArms = arms.flatMap((a) => (a.y === undefined || a.headSrc === undefined || a.headFirst === undefined ? [] : [{ ...a, y: a.y, headSrc: a.headSrc, headFirst: a.headFirst }]));
+    const plainArms = arms.filter((a) => a.y === undefined);
+    const headScreen = new RegExp(`(?:${boundaryArms.map((a) => a.headSrc).join("|")})`, "y");
+    const headFirstUnit = unionMembers(boundaryArms.map((a) => a.headFirst)) ?? new Uint32Array(0x10000 >>> 5).fill(0xffffffff);
+    poolArmCount = arms.length;
+    poolBoundaryArmCount = boundaryArms.length;
     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);
-            }
-            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))
-                        continue;
-                    tried.add(e);
-                    at.push(e);
+            for (const a of plainArms)
+                collectRegexSpans(a, text, spans);
+            for (const a of boundaryArms)
+                collectValueArmSpans(a, text, spans);
+            if (boundaryArms.length > 0 && spans.length > 0) {
+                const tried = new Uint8Array(text.length + 1);
+                const freshCovered = (from) => {
+                    const at = [];
+                    for (let k = from; k < spans.length; k++) {
+                        const s = spans[k];
+                        for (let p = s.start; p <= s.end; p++) {
+                            if (tried[p] === 1)
+                                continue;
+                            tried[p] = 1;
+                            coveredPositions += 1;
+                            if (unitBit(headFirstUnit, text.charCodeAt(p)) !== 1)
+                                continue;
+                            headScreen.lastIndex = p;
+                            if (headScreen.exec(text) === null)
+                                continue;
+                            at.push(p);
+                        }
+                    }
+                    headScreenHits += at.length;
+                    return at.sort((x, y) => x - y);
+                };
+                for (let at = freshCovered(0); at.length > 0;) {
+                    const before = spans.length;
+                    for (const a of boundaryArms)
+                        collectStickySpans(a, text, at, spans);
+                    at = freshCovered(before);
                 }
-                return at.sort((x, y) => x - y);
-            };
-            for (let at = freshEnds(0); 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);
             }
+            poolSpanCount += spans.length;
             const kept = resolveSpanOverlaps(spans);
             const out = applySpans(text, kept).out;
             if (!wantCount || kept.length === 0)
@@ -1206,7 +1339,6 @@ const SECRET_RULES = [
     { 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 }) },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.79.1",
+  "version": "7.79.2",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",