@sema-agent/server 7.131.0 → 7.133.0

package/dist/trace/projection-table.js

@@ -0,0 +1,130 @@
+import { redactErrorMessage } from "../observability/run-terminal.js";
+import { dropProjectedFace } from "./projection-drop.js";
+import { redactSecrets } from "./redact.js";
+export function projectByTable(face, table, value, root) {
+    return projectNode(face, table, value, root);
+}
+const isRecord = (v) => typeof v === "object" && v !== null;
+const DISPOSITION_KEYS = ["mint", "forward", "redact", "nested", "rows", "admit"];
+function projectNode(path, table, value, root) {
+    const out = {};
+    for (const [key, entry] of Object.entries(table)) {
+        const at = `${path}.${key}`;
+        if (entry === "strip")
+            continue;
+        if (entry === "forward") {
+            const raw = Reflect.get(value, key);
+            if (raw !== undefined)
+                out[key] = raw;
+            continue;
+        }
+        if (!isRecord(entry))
+            throw unknownWord(at, entry);
+        const present = DISPOSITION_KEYS.filter((k) => Object.hasOwn(entry, k));
+        const words = present.filter((k) => k !== "rows" && k !== "admit");
+        if (words.length === 0)
+            throw unknownWord(at, entry);
+        if (words.length > 1 || (words[0] !== "nested" && present.length > 1)) {
+            throw new Error(`projection_table: ${at} carries more than one disposition (${present.join(", ")}) — one cell, one word`);
+        }
+        if (words[0] === "mint") {
+            if (typeof entry.mint !== "function")
+                throw unknownWord(at, entry);
+            const minted = entry.mint(value, root);
+            if (minted !== undefined)
+                out[key] = minted;
+            continue;
+        }
+        const raw = Reflect.get(value, key);
+        if (raw === undefined)
+            continue;
+        if (words[0] === "forward") {
+            if (typeof entry.forward !== "function")
+                throw unknownWord(at, entry);
+            if (entry.forward(raw) === true)
+                out[key] = raw;
+            else
+                drop(at, "is present but its narrow read rejects it");
+            continue;
+        }
+        if (words[0] === "redact") {
+            if (typeof entry.redact !== "string")
+                throw unknownWord(at, entry);
+            const redacted = redactWith(entry.redact, raw, at);
+            if (redacted !== undefined)
+                out[key] = redacted;
+            continue;
+        }
+        const projected = projectNested(at, entry, raw, root);
+        if (projected !== undefined)
+            out[key] = projected;
+    }
+    return out;
+}
+function projectNested(at, entry, raw, root) {
+    const sub = entry.nested;
+    if (!isRecord(sub))
+        throw unknownWord(at, entry);
+    if (entry.admit !== undefined && typeof entry.admit !== "function")
+        throw unknownWord(at, entry);
+    if (typeof entry.admit === "function" && entry.admit(raw) !== true) {
+        return drop(at, "is present but its narrow read rejects it");
+    }
+    const rows = entry.rows;
+    if (rows === undefined) {
+        if (!isRecord(raw) || Array.isArray(raw))
+            return drop(at, "is present but not an object");
+        return projectNode(at, sub, raw, root);
+    }
+    if (!Array.isArray(raw))
+        return drop(at, "is present but not a list");
+    let carried;
+    if (rows === "each")
+        carried = raw;
+    else if (typeof rows === "function") {
+        const selected = rows(raw, root);
+        if (!Array.isArray(selected))
+            throw new Error(`projection_table: ${at} rows selector returned a non-list`);
+        const pool = new Set(raw);
+        if (selected.some((element) => !pool.has(element))) {
+            throw new Error(`projection_table: ${at} rows selector returned an element that is not in the list — rows may only select / reorder`);
+        }
+        carried = selected;
+    }
+    else
+        throw unknownWord(at, entry);
+    const out = [];
+    for (const element of carried) {
+        if (isRecord(element) && !Array.isArray(element))
+            out.push(projectNode(`${at}[]`, sub, element, root));
+        else
+            drop(`${at}[]`, "element is present but not an object");
+    }
+    return out;
+}
+function redactWith(word, raw, at) {
+    const entry = word;
+    const asText = (scrub) => (typeof raw === "string" ? scrub(raw) : drop(at, "is present but not text"));
+    switch (entry) {
+        case "redactSecrets":
+            return asText(redactSecrets);
+        case "redactErrorMessage":
+            return asText(redactErrorMessage);
+        default: {
+            const unhandled = entry;
+            throw unknownWord(at, { redact: unhandled });
+        }
+    }
+}
+function drop(at, why) {
+    return dropProjectedFace("projection_table." + at + " " + why);
+}
+function unknownWord(at, entry) {
+    const shown = typeof entry === "string"
+        ? JSON.stringify(entry)
+        : isRecord(entry)
+            ? `{${Object.entries(entry).map(([k, v]) => `${k}:${typeof v === "string" ? v : typeof v}`).join(",")}}`
+            : String(entry);
+    return new Error(`projection_table: ${at} carries a disposition the interpreter does not know: ${shown}`);
+}
+//# sourceMappingURL=projection-table.js.map

package/dist/trace/redact.d.ts

@@ -29,10 +29,30 @@ export declare function armPoolBudgetForTest(): {
     armCount: number;
     boundaryArmCount: number;
     forensicLevels: number;
+    forensicRuns: number;
+    forensicSkips: number;
+    urlSegmentRuns: number;
+    urlSegmentReplays: number;
     ssh2ScanBytes: number;
     mappedUnits: number;
 };
 export declare function resetArmPoolBudgetForTest(): void;
+/**
+ * 🔴 **脱敏的两个档 —— 「这段文本是自由文本,还是一个结构有界的单元」**(S-526,闭集两词)。
+ *
+ * · `"free-text"`:CoT / 日志 / 任意字节。臂**全员**在场,读数就是 {@link redactSecrets} 的对外语义。
+ * · `"bounded-unit"`:一个 URL 路径段、一个 query 键名或值 —— 边界由**结构**给(WHATWG 已经把界告诉我们了)。
+ *   这一档**去掉词法关键字臂**:它们的判别力来自自由文本的语法,而单元里没有那种语法(见
+ *   {@link unitCarriesCredential} 顶注的病理)。值形臂与结构锚臂两族都**留在档里** —— 判别力分别是
+ *   「前缀 + 值形」与一条**字面结构锚**(`-----BEGIN` / `://u:p@` / JSON 秘密字段名)。
+ *   ⚠️ **只有值形臂那一族在单元里真的开火**(异源复审 270 形实测纠错):结构锚臂**留着但恒空转** —— 锚里的
+ *   空格 / `:` / `@` / `"` / `{` 不属于**任何**臂的值字符类,{@link boundedUnitView} 的补位会把它们逐个换掉,
+ *   锚在每一份视图里都被摧毁。把结构锚臂一并踢出本档,270 形读数**零差**。留着它们是因为「谁的判别力依赖
+ *   自由文本语法」这条**判据**上它们本就不该被排除(踢掉是另一条理由),不是因为它们在这里还起作用。
+ *
+ * 闭集:加一个档而不在 {@link armPool} 的档表里处置 ⇒ **编译**红。
+ */
+type RedactionScope = "free-text" | "bounded-unit";
 /** 本模块会写进文本的全部替换 token(`«…»` 字面),从三张表现算 —— 表改这里自动跟,不另抄一份。
  *  🔴 **S-223 v2 修复轮起它只剩一个语义:闭形闭集的加载期校验**。运行期「这一段是不是一枚记号」已经由
  *  {@link credentialSpans} 的闭**形**那一支一处答完({@link opaqueUnitEnd}),按闭**集**再认一遍的
@@ -44,6 +64,23 @@ declare const DISPLAY_SAFE_URL_TOKEN = "\u00ABredacted:url\u00BB";
 /** S-776:出网代理 URL 的回显尺(`outbound-dispatcher.ts` `displayProxyUrl`)形不干净时整只用**同一枚**占位 —— 单独一行导出,
  *  上面那行字面量保持 `const NAME = "…";` 形(`test/api-notice-text-freeze.test.ts` §6 的冻结扫描按这一形认替换 token)。 */
 export { DISPLAY_SAFE_URL_TOKEN };
+/**
+ * 🔴 **取证相的重扫模式(测试座,S-375)** —— 生产恒 `"incremental"`;`"full"` 是**参照语义** = 「没有可复用的上一次执行」:
+ * 每级五条取证臂整段重跑、URL 臂每段重扫,既不读足迹也不回放(池把每一级的脏区间当作「未知」交下去,与级 0 同一个读法)。
+ * 证据表的建法(级 0 记号档 + 逐级折入)与收敛判据(脏区间为空)两种模式是同一条,所以两种模式只差「复用与否」这一位 ——
+ * 增量重扫的全部正确性主张只有一句:**任何输入上两种模式输出逐字相同**(`test/forensic-incremental-rescan.test.ts` 并跑比对;
+ * 折入本身与整表重建的对拍是那个测试文件里的一份测试本地参照)。
+ */
+export type ForensicRescanMode = "incremental" | "full";
+export declare function setForensicRescanModeForTest(mode: ForensicRescanMode): void;
+/** 测试座:折入函数的数组形(`prev` 须是合法的已并表:升序、两两不交不相接)。 */
+export declare function credentialSpansFoldForTest(prev: ReadonlyArray<readonly [number, number]>, add: ReadonlyArray<readonly [number, number]>): {
+    next: Array<[number, number]>;
+    dirty: Array<[number, number]>;
+};
+/** 🧪 结构读数(与 {@link ppkScanBytesForTest} 同一条技法):本扫描器读过的单元数,线性钉用。 */
+export declare function anchoredScanUnitsForTest(): number;
+export declare function resetAnchoredScanUnitsForTest(): void;
 /** 测试可见(S-265 真值表的两半):结构段里**表行只作声明、实现是手写扫描器**的臂 —— 声明正则的**新拷贝**
  *  (`lastIndex` 不与模块内那一枚共享)+ 扫描器在一份原文上产的候选跨度 `[起, 止)`。臂名是闭集 ⇒ 穷尽 `switch`
  *  (少一个 `case` = 缺返回 = 编译红)。 */
@@ -125,6 +162,23 @@ export declare function redactionSpansForTest(text: string, opts?: {
         readonly end: number;
     }>;
 };
+/**
+ * 🔴 **出口座的提案口**(S-485 / RH-1 第一期;座 = `src/trace/exit-seat.ts` 的 `seatText`)。
+ *
+ * 同一只 {@link runRedaction}、同一遍扫描、同一次观察者计数(`observe` 与 {@link redactSecrets} 的缺省同口 —— 座上的一次脱敏就是一次
+ * 主扫),交出**原文坐标**上的跨度与各自的替换串:臂认什么、档里有哪些臂,仍然只由本模块答。座拿它做**一次区间合并 + 一次渲染**
+ * (合并律与渲染律住在座里,本模块不拼第二份产物给座)。
+ *
+ * 第一期交的是池解完重叠之后的那一份(升序、两两不交);第二期改交未解重叠的原始候选,池内并集律 {@link resolveSpanOverlaps} 与
+ * {@link applySpans} 随之删除 —— 那时本口是自由文本脱敏的唯一出口。
+ */
+export type RedactionSpan = {
+    readonly start: number;
+    readonly end: number;
+    readonly repl: string;
+};
+export type { RedactionScope };
+export declare function proposeRedactionSpans(text: string, scope: RedactionScope): readonly RedactionSpan[];
 /**
  * 🔴 环 + 深度预算(2026-07-25 补)。原实现是纯递归、**既不记已访问节点也不限深度**,而它的调用位置是
  * **最不可信的边界**:`toolStart`/`toolEnd` 把工具的 `args`/`output`/`structured` 直接喂进来。后果两条: