@sema-agent/settings-schema 14.6.0 → 14.7.0

package/dist/config-fns.js

@@ -17,7 +17,8 @@
 // its entry collections. zod is this package's one runtime dependency, so this costs nothing new.
 import { z } from "zod";
 import { MODEL_ENTRY_REFUSAL_CODES, ModelRefusalsWire } from "./fleet.js";
-import { isPlainJsonObject } from "./plain-json-object.js";
+import { UNINSPECTABLE, dataDescriptor, emptyDocument, guardedSafeParse, inspect, isAccessorDescriptor, isolatedObject, ownEntriesOf, ownRow, ownValueOf } from "./own-key-read.js";
+import { isJsonArray, isPlainJsonObject, jsonShapeOf } from "./plain-json-object.js";
 import { carriesUserinfo, secretScanForms } from "./secret-scan.js"; // package-private normalization (both scanners read it) + the userinfo judgement (not in the barrel)
 import { sha256Hex } from "./sha256.js";
 import { unwrapSchema } from "./zod-unwrap.js"; // package-private: the ONE reading of zod's wrapper layers (salvage + the one-time migrations share it)
@@ -103,12 +104,12 @@ function boundIssueIdentifiers(rec) {
             changed.set(v, out);
         return out;
     };
-    if (Array.isArray(rec.path))
+    if (isJsonArray(rec.path))
         rec.path = rec.path.map(bound);
-    if (Array.isArray(rec.keys))
+    if (isJsonArray(rec.keys))
         rec.keys = rec.keys.map(bound);
     const params = rec.params;
-    if (params !== undefined && Array.isArray(params.template) && Array.isArray(params.operands)) {
+    if (params !== undefined && isJsonArray(params.template) && isJsonArray(params.operands)) {
         const quoted = { template: params.template, operands: params.operands.map((o) => bound(o)) };
         rec.params = { ...params, ...quoted };
         rec.message = renderQuotedSentence(quoted);
@@ -124,14 +125,31 @@ function sanitizeIssueValue(v, depth) {
         return redactSecrets(v);
     if (typeof v === "symbol")
         return redactSecrets(String(v));
-    if (v === null || typeof v !== "object")
-        return v;
-    if (depth > SANITIZE_MAX_DEPTH)
-        return "[redacted-secret]";
-    if (Array.isArray(v))
-        return v.map((el) => sanitizeIssueValue(el, depth + 1));
-    sanitizeIssueFields(v, depth);
-    return v;
+    const shape = jsonShapeOf(v);
+    switch (shape) {
+        case "null":
+        case "primitive":
+            return v;
+        case "uninspectable":
+            return "[redacted-secret]"; // a value the walk cannot read is withheld, like one the depth bound does not reach
+        case "array": {
+            if (depth > SANITIZE_MAX_DEPTH)
+                return "[redacted-secret]";
+            const items = inspect(() => v.map((el) => sanitizeIssueValue(el, depth + 1))); // a member that cannot be read (a getter / trap that throws) ⇒ the whole value is withheld
+            return items.ok ? items.value : "[redacted-secret]";
+        }
+        case "plain":
+        case "non_plain_object": {
+            if (depth > SANITIZE_MAX_DEPTH)
+                return "[redacted-secret]";
+            const walked = inspect(() => sanitizeIssueFields(v, depth)); // same: a member read or write that throws ⇒ the whole value is withheld
+            return walked.ok ? v : "[redacted-secret]";
+        }
+        default: {
+            const unhandled = shape;
+            throw new Error(`sanitizeIssueValue: unhandled shape ${String(unhandled)}`);
+        }
+    }
 }
 export const ROLE_RANK = { viewer: 0, editor: 1, publisher: 2, admin: 3 };
 export const USER_ROLES = ["viewer", "editor", "publisher", "admin"];
@@ -181,7 +199,7 @@ export const DOMAIN_WRITE_ROLE = {
 };
 /** The minimum role required to write `domain` (the raised gate for skills/mcp, else editor). */
 export function domainWriteRole(domain) {
-    return DOMAIN_WRITE_ROLE[domain] ?? DEFAULT_DOMAIN_WRITE_ROLE;
+    return ownRow(DOMAIN_WRITE_ROLE, domain) ?? DEFAULT_DOMAIN_WRITE_ROLE;
 }
 /** The empty/defaults effective config at version 0 — what publish mode serves before the first publish.
  *  Seeds the epoch (`new Date(0)`) so it's deterministic (the wall-clock default was the original store.ts
@@ -230,17 +248,20 @@ export function parseDomain(domain, raw) {
         throw new Error(`"${outgoingSegment(String(domain))}" is not a config domain`);
     // ONLY true absence (undefined) defaults; an explicit `null` (e.g. a `config.d/<d>.json` containing JSON
     // `null`) is corrupt input → let zod reject it ("expected object, received null"), not silently default. R4.
-    let r;
-    try {
-        r = DOMAIN_SCHEMAS[domain].safeParse(raw === undefined ? {} : raw);
-    }
-    catch {
-        // a hostile getter/Proxy trap threw during traversal — its message may carry a secret; never surface it. R13.
-        throw new Error(`invalid "${domain}" config (a value could not be read during validation)`);
-    }
-    if (r.success)
-        return r.data;
-    throw sanitizeZodError(r.error); // recursive redaction (message / every issue field / nested issues) — no secret echo. R13/R14.
+    return strictParse(DOMAIN_SCHEMAS[domain], domain, raw === undefined ? emptyDocument() : raw);
+}
+/**
+ * 一次**整份严判**(域文档与 wire 上的 skills 清单共用这一只 —— 清单的读法与非门控域同一臂,见 `readSkillsManifest`):过 ⇒ 数据;
+ * 不过 ⇒ 抛脱敏后的 ZodError(逐字段递归脱敏,不回显秘密;R13/R14);校验过程抛(含首读 `error` 时抛,见 {@link guardedSafeParse})⇒ 抛 {@link unreadableDomainError}
+ * (抛出值的文案可能带秘密,从不转述;R13)。
+ */
+function strictParse(schema, label, doc) {
+    const judged = guardedSafeParse(() => schema.safeParse(doc), sanitizeZodError);
+    if (!judged.ok)
+        throw unreadableDomainError(label);
+    if (judged.value.success)
+        return judged.value.data;
+    throw judged.value.error;
 }
 /** 一个**逐字出门**的字符串段的样子 —— 一条判据,不是一串特例:**逐字写出去之后读回来只能是它自己**。
  *  所以四类字符串段必须改走引号形:空串、含 `.`(段分隔符)、含 `"`(引号形自身)或控制字符的,以及
@@ -348,7 +369,7 @@ function readEntryIdentity(entry) {
             return undefined;
         const own = (k) => {
             const d = Object.getOwnPropertyDescriptor(entry, k);
-            return d !== undefined && Object.hasOwn(d, "value") ? d.value : undefined; // 描述符本身也只读自有键
+            return d !== undefined && !isAccessorDescriptor(d) ? d.value : undefined; // 访问器不调(描述符的字段只认自有的,见内核)
         };
         const name = own("name");
         const id = own("id");
@@ -385,17 +406,18 @@ function droppedEntry(path, verdict, entry) {
 }
 /** 一次「什么都没丢」的抢救的位移表(冻结的共享空表 —— {@link rebaseWarningPaths} 对它恒等)。 */
 const NO_ENTRIES_DROPPED = Object.freeze({});
+/** 一个域的校验过程抛了(恶意 getter / Proxy 陷阱 / 校验器自己对怪形值做类型转换)⇒ 给调用方的那一句中性话:不带抛出值的文案(可能带 secret),类是 `TypeError`(调用方给的值读不出是调用方的错)。 */
+function unreadableDomainError(domain) {
+    return new TypeError(`invalid "${domain}" config (a value could not be read during validation)`);
+}
 /** 一条条目的 parse —— 坏就返回它的判决(脱敏错误 + 闭集词)。`rejectedAs` = 调用点在集合里的位置赋予「schema 没过」的那个词
  *  (条目 / Record 值 ⇒ `entry-schema-invalid`;Record 键 ⇒ `entry-key-invalid`);判的过程抛了则恒为 `entry-unreadable`,与位置无关。
  *  恶意 getter/Proxy 在遍历中抛错时**绝不**外泄其文案(可能带 secret,与 parseDomain 的 R13 同纪律),只留一句中性话。 */
 function judgeEntry(schema, value, rejectedAs) {
-    try {
-        const r = schema.safeParse(value);
-        return r.success ? undefined : { error: sanitizeZodError(r.error), reasonCode: rejectedAs };
-    }
-    catch {
-        return { error: new Error("entry could not be read during validation"), reasonCode: "entry-unreadable" };
-    }
+    const judged = guardedSafeParse(() => schema.safeParse(value), sanitizeZodError); // 脱敏也在守护里:issue 读不完(`params` 里会抛的 getter)⇒ 这一条读不出(v14.6.0 同)
+    if (!judged.ok)
+        return { error: new TypeError("entry could not be read during validation"), reasonCode: "entry-unreadable" }; // 同一原因(校验时值读不出)一种错类:与 `domain-defaulted` 告警的 error 同为 TypeError
+    return judged.value.success ? undefined : { error: judged.value.error, reasonCode: rejectedAs };
 }
 /**
  * 从**schema 自身**派生条目集合(数组字段 / Record 字段),逐条判,坏的丢掉并逐条记账。
@@ -441,12 +463,8 @@ export function salvageEntries(schema, raw) {
 /** 一层抢救,抢不动就当没抢救(反射 / 访问器抛错:绝不外泄其文案)。最外层与每一条条目体内走的是**同一只** —— 一条条目体内抢不动,
  *  只是这一条不下钻、照原样去判,不连坐它所在的那一层。 */
 function salvageLayer(schema, raw) {
-    try {
-        return salvageLayerUnsafe(schema, raw);
-    }
-    catch {
-        return { raw, dropped: [], shifts: [] };
-    }
+    const layer = inspect(() => salvageLayerUnsafe(schema, raw));
+    return layer.ok ? layer.value : { raw, dropped: [], shifts: [] };
 }
 /** 集合字段的值 → 它的位置表;值的形与 schema 对不上(schema 说数组、文档给对象)⇒ `undefined`(不抢救,交给整域档位)。
  *  数组走 `forEach`(不是手写 `for (i < value.length)`):它在**进入时**就钉死了长度,而重读 `value.length` 会跟着一个在校验期间
@@ -454,7 +472,7 @@ function salvageLayer(schema, raw) {
  *  位置表在任何判定之前就收齐了,之后数组再怎么长都与本次抢救无关。`forEach` 跳过空洞,与此前的 `filter` 同。 */
 function collectionSlots(value, isArray) {
     if (isArray) {
-        if (!Array.isArray(value))
+        if (!isJsonArray(value))
             return undefined;
         const slots = [];
         value.forEach((entry, i) => void slots.push([i, entry]));
@@ -478,7 +496,10 @@ function salvageLayerUnsafe(schema, raw) {
         const isArray = collection instanceof z.ZodArray;
         if (!isArray && !(collection instanceof z.ZodRecord))
             continue; // 不是条目集合:连读都不读(少触发一次访问器)
-        const slots = collectionSlots(raw[field], isArray);
+        const held = ownValueOf(raw, field); // the field is read from the document's OWN keys (a polluted `Object.prototype.<field>` is not a collection the document holds); unreadable ⇒ nothing to salvage here
+        if (!held.ok)
+            return untouched;
+        const slots = collectionSlots(held.value, isArray);
         if (slots === undefined)
             continue;
         const element = (collection instanceof z.ZodArray ? collection.element : collection.valueType);
@@ -729,13 +750,13 @@ export const EXTENSION_NAMESPACES = {
  *  本身——键名里可以含 `.`(`semaX.foo` 是一个键不是两层),段形让这件事不必再靠文法猜;前缀契约就是前缀
  *  契约(`semaGPT_5` / `semaX-v2` 都是成员,后缀不设未声明的文法)。 */
 export function isReservedExtensionKey(domain, parent, key) {
-    const rules = EXTENSION_NAMESPACES[domain];
+    const rules = ownRow(EXTENSION_NAMESPACES, domain);
     return rules !== undefined && rules.some((r) => r.at.length === parent.length && r.at.every((seg, i) => (seg === ANY_INDEX ? typeof parent[i] === "number" : seg === parent[i])) && r.key.test(key));
 }
 function collectDropped(domain, raw, parsed, prefix, depth, acc) {
     if (depth > DROP_SCAN_MAX_DEPTH)
         return;
-    if (Array.isArray(raw) && Array.isArray(parsed)) {
+    if (isJsonArray(raw) && isJsonArray(parsed)) {
         // 长度不同 = 整条元素被丢(`entry-dropped` 有自己的警告),不在本判据内,别造重复噪声。
         if (raw.length !== parsed.length)
             return;
@@ -818,13 +839,18 @@ const OPEN_WORLD_KNOWN_KEYS = {
  * 子树)不再下探,那本就是消费方自定义的内容,逐层猜没有意义。
  */
 function carriedUnknownKeys(domain, parsed) {
-    const table = OPEN_WORLD_KNOWN_KEYS[domain];
+    const table = ownRow(OPEN_WORLD_KNOWN_KEYS, domain);
     const acc = { keys: [], total: 0 };
     if (table === undefined)
         return acc;
     for (const [at, known] of table) {
         // 段形下探:`[]` 落在文档根上,所以「顶层 vs 嵌套」不再是两条分支(规则少一条)。
-        const node = at.reduce((cur, seg) => (isPlainJsonObject(cur) ? cur[String(seg)] : undefined), parsed);
+        const node = at.reduce((cur, seg) => {
+            if (!isPlainJsonObject(cur))
+                return undefined;
+            const read = ownValueOf(cur, String(seg));
+            return read.ok ? read.value : undefined;
+        }, parsed);
         if (!isPlainJsonObject(node))
             continue;
         for (const k of Object.keys(node)) {
@@ -892,16 +918,7 @@ function readDomainDocument(domain, raw, onWarning, whenUnreadable) {
 function parseSalvaged(domain, raw, unreadable, onWarning) {
     if (DOMAIN_ENTRY_SALVAGE[domain] !== "salvage")
         throw unreadable;
-    const salvage = salvageEntries(DOMAIN_SCHEMAS[domain], raw);
-    if (salvage.dropped.length === 0)
-        throw unreadable;
-    let parsed;
-    try {
-        parsed = parseDomain(domain, salvage.raw);
-    }
-    catch {
-        throw unreadable; // 条目之外还有毛病(重名 / 悬空 ref / 域级判据)—— 丢条目救不了它
-    }
+    const { parsed, salvage } = salvageThenParse(DOMAIN_SCHEMAS[domain], raw, (doc) => parseDomain(domain, doc), unreadable);
     if (onWarning) {
         // 坐标律(S-323b):一条告警用「铸它的那一层所见文档」的坐标表达;哪一层压缩了文档,哪一层就把从它下方上来的告警回写一次。
         // `entry-dropped` 是本层(salvage)铸的,用的就是本层入参那份文档的坐标 ⇒ 原样出门;未知键扫描是对本层**压缩后**文档的诊断 ⇒ 过本层的位移表。
@@ -911,6 +928,23 @@ function parseSalvaged(domain, raw, unreadable, onWarning) {
     }
     return parsed;
 }
+/**
+ * 逐条抢救的**那一步**(域面 {@link parseSalvaged} 与 wire 面 skills 清单 `readSkillsManifest` 共用 —— 一条律,两个调用点):整份严判已经失败
+ * (校验不过,或校验过程抛 —— 同一条臂:{@link salvageEntries} 逐条判,抛的那一条记 `entry-unreadable` 丢它自己)之后,丢掉坏条目再严判一次。
+ * 什么都没丢 / 丢了仍读不进(条目之外还有毛病:重名 / 悬空 ref / 域级判据;或抢救后的文档在重判时读不出)⇒ 抛 `unreadable`(第一次严判的原错)——
+ * 一个文档一个结论,没救活就不留「丢了某条」的半路叙述。
+ */
+function salvageThenParse(schema, raw, parse, unreadable) {
+    const salvage = salvageEntries(schema, raw);
+    if (salvage.dropped.length === 0)
+        throw unreadable;
+    try {
+        return { parsed: parse(salvage.raw), salvage };
+    }
+    catch {
+        throw unreadable;
+    }
+}
 /** 未知键两条告警(剥掉的 / 承运的)—— `raw` 是这次真被 parse 的那份文档,`emit` 决定坐标出门前要不要回写。 */
 function announceUnknownKeys(domain, raw, parsed, emit) {
     const dropped = droppedKeys(domain, raw, parsed);
@@ -1098,9 +1132,31 @@ export function buildEffective(version, getRaw, updatedAt, onWarning) {
  *  and so does any key no domain names(the 0.6-era `teams` key included — not a domain since 0.7, and no engine reads it). Throws ONLY on garbage no caller can partially trust: a non-object payload, or a missing/
  *  non-finite `version` — that is not "a bad domain", it is not an effective config at all. */
 export function readEffectiveWire(raw, onWarning) {
-    if (!isPlainJsonObject(raw))
-        throw new Error("effective wire payload is not a JSON object");
-    const r = raw;
+    // 判形只问座位:读不出(撤销的 Proxy / 陷阱抛)是「读不出」—— 与下面读键读不出同一类同一句,不是「不是对象」;不是对象(null / 数组 / 原始值 / 类实例)才是既有的那句
+    const rawShape = jsonShapeOf(raw);
+    switch (rawShape) {
+        case "plain":
+            break;
+        case "uninspectable":
+            throw new TypeError(`effective wire payload could not be read — ${UNINSPECTABLE}`);
+        case "non_plain_object":
+        case "array":
+        case "null":
+        case "primitive":
+            throw new Error("effective wire payload is not a JSON object");
+        default: {
+            const unhandled = rawShape;
+            throw new Error(`readEffectiveWire: unhandled shape ${String(unhandled)}`);
+        }
+    }
+    // 载荷只读一次,读成它自有的键值快照(隔离原型 `COPY_PROTOTYPE` 的袋):信封键(`version` / `updatedAt`)、域键、`skills` / `prompts` 与未知键都从快照里取 ——
+    // 键只靠继承可见(`Object.prototype.models` 被污染成数据值)不算载荷里写着的;读不出(`get` 陷阱 / 会抛的 getter)⇒ 抛本函数自己的那一句,不是引擎的错
+    const entries = ownEntriesOf(raw); // 自有串键里有不可枚举的 ⇒ 整份读不出(不当缺席、不静默丢)
+    if (!entries.ok)
+        throw new TypeError(`effective wire payload could not be read — ${entries.sentence}`);
+    const r = isolatedObject(); // 载荷的袋:与所有副本同一只原型
+    for (const [k, v] of entries.value)
+        Object.defineProperty(r, k, dataDescriptor(v));
     if (typeof r.version !== "number" || !Number.isFinite(r.version))
         throw new Error("effective wire payload has no numeric version");
     const updatedAt = typeof r.updatedAt === "string" ? r.updatedAt : "";
@@ -1112,26 +1168,12 @@ export function readEffectiveWire(raw, onWarning) {
     // downstream as "the center withdrew its layer" — the consumer's judge refuses it loudly instead. verbatim, by presence(见 return)。
     const built = buildEffective(r.version, (d) => (d === "skills" || d === "prompts" ? undefined : r[d]), updatedAt, onWarning);
     // retired 域名不是 open-world 的未知键:墓碑已在 buildEffective 里判过(带事实 ⇒ 抛),剩下的 `{}` 没有可承运的东西。
-    let skills;
-    const manifest = SkillsManifestSchema.safeParse(r.skills ?? {});
-    if (manifest.success) {
-        skills = manifest.data;
-    }
-    else {
-        // 逐条容错律的 wire 腿:manifest 走的是另一张 schema,但**同一个**抢救点 —— 一条坏条目只丢它自己,
-        // 整张 skill 清单不再因此蒸发(零幸存者仍整份退默认,见 salvageEntries 头注)。
-        const salvage = salvageEntries(SkillsManifestSchema, r.skills);
-        const retry = salvage.dropped.length > 0 ? SkillsManifestSchema.safeParse(salvage.raw) : undefined;
-        if (retry?.success) {
-            for (const d of salvage.dropped)
-                onWarning?.(entryDroppedWarning("skills", d));
-            skills = retry.data;
-        }
-        else {
-            onWarning?.({ domain: "skills", kind: "domain-defaulted", error: sanitizeZodError(manifest.error) });
-            skills = { skills: [] };
-        }
-    }
+    const manifest = readSkillsManifest(r.skills);
+    // 告警在判完之后、读法之外发:`onWarning` 自己抛的错不会被当成「清单读不进」
+    if (onWarning)
+        for (const w of manifest.warnings)
+            onWarning(w);
+    const skills = manifest.skills;
     // Open-world passthrough: keys that are neither validated domains nor the envelope fields ride verbatim.
     // `hasOwnProperty.call(built, k)`,**不是** `k in built`(S-332):`in` 会一路问到 `Object.prototype`,
     // 于是 `constructor` / `toString` / `hasOwnProperty` / `__proto__` 这些**原型链上的名字**作未知顶层键时
@@ -1143,7 +1185,29 @@ export function readEffectiveWire(raw, onWarning) {
     // prompts:剥掉 buildEffective 恒物化的 `{}` 底座,按 wire 在场性 verbatim 挂回(#100:
     // 缺席进缺席出——发布闸关是常态形,物化会让消费端「缺席」分支永不可达)。
     const { prompts: _promptsMaterialized, ...builtSansPrompts } = built;
-    return { ...passthrough, ...builtSansPrompts, skills, ...("prompts" in r ? { prompts: r.prompts } : {}) };
+    return { ...passthrough, ...builtSansPrompts, skills, ...(Object.hasOwn(r, "prompts") ? { prompts: r.prompts } : {}) };
+}
+/**
+ * wire 上 skills 清单的读法 —— **与非门控域同一臂**,只是判的是清单 schema({@link SkillsManifestSchema}):整份严判({@link strictParse})→ 读不进
+ * (校验不过,或校验器自己抛 —— 合法 JSON 里的怪形值、嵌入方对象的 getter / 陷阱 —— 同一条臂)⇒ 逐条抢救({@link salvageThenParse}:坏条目丢它自己 + `entry-dropped`,
+ * 其余合法条目保留;零幸存者不凭空造空集合)→ 仍读不进 ⇒ 整份退默认(空清单)+ `domain-defaulted`(`error` = 第一次严判的原错:脱敏的 ZodError,或包自己那一句的 TypeError)。
+ * 缺席 ⇒ 按包自己造的空文档判(`COPY_PROTOTYPE`,读不到污染值)。告警交回给调用方发。
+ */
+function readSkillsManifest(raw) {
+    const parse = (doc) => strictParse(SkillsManifestSchema, "skills", doc);
+    try {
+        return { skills: parse(raw ?? emptyDocument()), warnings: [] };
+    }
+    catch (unreadable) {
+        try {
+            const { parsed, salvage } = salvageThenParse(SkillsManifestSchema, raw, parse, unreadable);
+            return { skills: parsed, warnings: salvage.dropped.map((d) => entryDroppedWarning("skills", d)) };
+        }
+        catch {
+            // 救不回 ⇒ 告警带第一次严判的原错(salvageThenParse 只重抛它;salvageEntries 是总的)—— 在结构上就是它,不靠「被捕获的恰好是它」
+            return { skills: { skills: [] }, warnings: [{ domain: "skills", kind: "domain-defaulted", error: unreadable }] };
+        }
+    }
 }
 /** 档位组→引擎单表的唯一解析点(0.9.0)。返回 ACTIVE 档位组的绑定表(剔除未绑档),即 core
  *  `RunnerDeps.tiers` 要吃的那张单表——组切换=web-admin 换这张表下发,零新引擎机制。无 active 组/未命中/

package/dist/conformance/canonical.js

@@ -10,7 +10,7 @@
  * `stableKey` 是唯一一处把值转成串的地方,它只用来给**多重集计数**当哈希键 —— 用的是 JSON 编码,
  * 数组边界与段类型(`"1"` vs `1`)在编码里都还在,所以它不是那种有损的点号串。
  */
-import { isPlainJsonObject } from "../plain-json-object.js";
+import { isJsonArray, isPlainJsonObject } from "../plain-json-object.js";
 /**
  * 「这个对象**在场**的键」—— 本文件里唯一一处判键在不在 / 取键的值的地方。
  *
@@ -37,7 +37,7 @@ function presentKeys(o) {
  * 「键不在场」与「键在场但值是 undefined」在比对上分成两件事,而 wire 上它们同形)。
  */
 export function canonicalize(value) {
-    if (Array.isArray(value))
+    if (isJsonArray(value))
         return value.map(canonicalize);
     if (isPlainJsonObject(value)) {
         // `Object.fromEntries`,**不是**逐键 `out[k] = …`:后者对 `"__proto__"` 走的是原型 setter(改掉对象的
@@ -55,7 +55,7 @@ export function stableKey(value) {
 export function deepEqual(a, b) {
     if (Object.is(a, b))
         return true;
-    if (Array.isArray(a) && Array.isArray(b))
+    if (isJsonArray(a) && isJsonArray(b))
         return a.length === b.length && a.every((x, i) => deepEqual(x, b[i]));
     if (isPlainJsonObject(a) && isPlainJsonObject(b)) {
         const ka = presentKeys(a);
@@ -78,7 +78,7 @@ export function diffJson(expected, actual, at = []) {
     const path = at.length === 0 ? "" : "/" + at.map(pointerSegment).join("/");
     if (deepEqual(expected, actual))
         return [];
-    if (Array.isArray(expected) && Array.isArray(actual)) {
+    if (isJsonArray(expected) && isJsonArray(actual)) {
         const out = [];
         for (let i = 0; i < Math.max(expected.length, actual.length); i++) {
             if (i >= expected.length)

package/dist/conformance/contract-adapter.js

@@ -24,8 +24,33 @@
 import { materializeLocalRoot } from "./run.js";
 import { contractOwnedEntry, contractOwnedEntryWhy } from "./entry-origin.js";
 import { LEG_NAMES, REF_INTEGRITY_REJECT_CODE } from "./types.js";
+import { inspect } from "../own-key-read.js";
+import { isJsonArray, jsonShapeOf } from "../plain-json-object.js";
 /** ZodError 形(鸭子判,不用 `instanceof` —— historical 模式下旧版 dist 可能挂在另一份 zod 上)。 */
-const isZodLike = (e) => e !== null && typeof e === "object" && Array.isArray(e.issues);
+/** A thrown value that looks like a zod error (an object — not a function — with an `issues` array on it; v14.6.0's `typeof e === "object"` test, nothing more). Shape from the seat;
+ *  the one member read goes through the inspection kernel. The seat reads the prototype once to classify, but the answer never depends on it: an object whose shape cannot
+ *  be read (a `getPrototypeOf` trap that throws) is still asked for `issues` — a thrown proxy whose `issues` cannot be read is not zod-like. */
+const isZodLike = (e) => {
+    const shape = jsonShapeOf(e);
+    switch (shape) {
+        case "null":
+        case "primitive":
+            return false;
+        case "array":
+        case "plain":
+        case "non_plain_object":
+        case "uninspectable": {
+            if (typeof e === "function")
+                return false; // 被抛的函数不是 zod 错(v14.6.0 的 `typeof e === "object"` 前置判把函数排除在外)
+            const issues = inspect(() => e.issues);
+            return issues.ok && isJsonArray(issues.value);
+        }
+        default: {
+            const unhandled = shape;
+            throw new Error(`isZodLike: unhandled shape ${String(unhandled)}`);
+        }
+    }
+};
 /** 内容哈希那一层拒绝的自述 —— `stableStringify` 的深度闸是**本包自己**抛的、也只有它会抛这一句;
  *  适配器给自家流水线分层,认得自家那句话是合理的(消费方的适配器认它自己那几层的错)。 */
 const HASH_STAGE_MARK = "stableStringify:";

package/dist/conformance/corpus.js

@@ -20,7 +20,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { LEG_NAMES, REJECT_STAGES } from "./types.js";
 import { LEG_EXPECTATION } from "./derive.js";
-import { isPlainJsonObject } from "../plain-json-object.js";
+import { isJsonArray, isPlainJsonObject } from "../plain-json-object.js";
 /** 本包的根目录 —— `src/conformance/*.ts` 与 `dist/conformance/*.js` 距根同深,两处求值同一个地方。 */
 export const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 /** 语料目录(默认 = 本包的 `conformance/`)。 */
@@ -45,7 +45,7 @@ function checkLegExpectation(v, where) {
     }
     if (r.outcome === "effective") {
         requireRecord(r.effective, `${where}.effective`);
-        if (!Array.isArray(r.warnings))
+        if (!isJsonArray(r.warnings))
             throw new Error(`conformance corpus: ${where}.warnings must be an array`);
         const meta = requireRecord(r.metadata, `${where}.metadata`);
         if (typeof meta.updatedAt !== "string")
@@ -56,7 +56,7 @@ function checkLegExpectation(v, where) {
         if (!REJECT_STAGES.includes(r.stage))
             throw new Error(`conformance corpus: ${where}.stage must be one of ${REJECT_STAGES.join("|")}`);
         if (r.refIssues !== undefined) {
-            const ok = Array.isArray(r.refIssues) && r.refIssues.every((x) => isPlainJsonObject(x) && Array.isArray(x.path) && x.path.every((seg) => typeof seg === "string" || typeof seg === "number"));
+            const ok = isJsonArray(r.refIssues) && r.refIssues.every((x) => isPlainJsonObject(x) && isJsonArray(x.path) && x.path.every((seg) => typeof seg === "string" || typeof seg === "number"));
             if (!ok)
                 throw new Error(`conformance corpus: ${where}.refIssues must be an array of { path: (string|number)[] }`);
         }
@@ -76,7 +76,7 @@ export async function loadCase(dir, id) {
     requireRecord(input.domains, `${id}/input.json#domains`);
     if (typeof meta.claim !== "string" || meta.claim.trim().length === 0)
         throw new Error(`conformance corpus: ${id}/meta.json#claim is empty — 每条语料必须写它想打谁`);
-    if (!Array.isArray(meta.firstRedOn))
+    if (!isJsonArray(meta.firstRedOn))
         throw new Error(`conformance corpus: ${id}/meta.json#firstRedOn must be an array`);
     const legs = {};
     for (const leg of LEG_NAMES) {

package/dist/conformance/derive.js

@@ -36,7 +36,7 @@
  */
 import { NON_DOMAIN_CONFIG_FILES } from "../file-store.js";
 import { PORTABLE_DOMAINS } from "../portable-domains.js";
-import { isPlainJsonObject } from "../plain-json-object.js";
+import { isJsonArray, isPlainJsonObject } from "../plain-json-object.js";
 import { skillContentHash } from "../skills-manifest.js";
 import { DOMAINS, isDomainName } from "../types.js";
 /** 变换表(本文件头注的机器形;`docs/CONFORMANCE.md` 与 `test/conformance-coverage.test.ts` 都读它)。 */
@@ -72,7 +72,7 @@ export const foreignKeysOf = (docs) => Object.keys(docs).filter((k) => !isDomain
 /** T2 的**入参**半场:域形的 skills 文档 → wire 形的 manifest 文档。结构变换,不解析 —— 坏形原样传下去,
  *  让 wire 腿自己的判据去裁(否则语料就没法喂一份坏 manifest 了)。 */
 export function toManifestDoc(doc) {
-    if (!isPlainJsonObject(doc) || !Array.isArray(doc.skills))
+    if (!isPlainJsonObject(doc) || !isJsonArray(doc.skills))
         return doc;
     return {
         ...doc,

package/dist/conformance/run.js

@@ -14,7 +14,7 @@
 import { mkdtemp, mkdir, readFile, realpath, rm, stat, writeFile, utimes } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, extname, isAbsolute, join, resolve, sep } from "node:path";
-import { isPlainJsonObject } from "../plain-json-object.js";
+import { isJsonArray, isPlainJsonObject, jsonShapeOf } from "../plain-json-object.js";
 import { canonicalize, deepEqual, diffJson, stableKey } from "./canonical.js";
 import { diffWarningMultiset, findSecretLeaks, projectWarning } from "./warnings.js";
 import { deriveLocalExpectation, deriveLocalInput, deriveWireExpectation, deriveWireInput, toManifestDoc } from "./derive.js";
@@ -178,7 +178,7 @@ function ledgerIndexForOutcome(ledger, caseId, leg, shape) {
         if (o === undefined)
             continue;
         // 形不合法的登记(`cases` 缺席/空 —— 违例已单记)绝不因此**扩大**覆盖:它谁都不命中,fail-closed。
-        if (o.leg !== leg || !Array.isArray(o.cases) || !o.cases.includes(caseId))
+        if (o.leg !== leg || !isJsonArray(o.cases) || !o.cases.includes(caseId))
             continue;
         if (o.expected !== shape.expected || o.actual !== shape.actual)
             continue;
@@ -289,12 +289,49 @@ function isCalendarDate(v) {
     return !Number.isNaN(d.getTime()) && d.toISOString().slice(0, 10) === v;
 }
 function stanceOf(adapter, leg) {
+    // an adapter is CODE (a stance may be a class instance with `run` on its prototype), not data: its members are read as an object's members — what the seat decides is only "is it an object at all"
     const legs = adapter.legs;
-    const s = legs !== null && typeof legs === "object" ? legs[leg] : undefined;
+    const legsShape = jsonShapeOf(legs);
+    let legsIsObject;
+    switch (legsShape) {
+        case "null":
+        case "primitive":
+        case "uninspectable":
+            legsIsObject = false;
+            break;
+        case "plain":
+        case "array":
+            legsIsObject = true;
+            break;
+        case "non_plain_object":
+            legsIsObject = typeof legs !== "function"; // 类实例是对象;函数不是(v14.6.0 的 `typeof === "object"` 判法:函数 ⇒ 没表态)
+            break;
+        default: {
+            const unhandled = legsShape;
+            throw new Error(`stanceOf: unhandled shape ${String(unhandled)}`);
+        }
+    }
+    const s = legsIsObject ? legs[leg] : undefined;
     if (s === undefined)
         return { kind: "missing" };
-    if (s === null || typeof s !== "object")
-        return { kind: "malformed", why: "the stance is not an object" };
+    const stanceShape = jsonShapeOf(s);
+    switch (stanceShape) {
+        case "null":
+        case "primitive":
+        case "uninspectable":
+            return { kind: "malformed", why: "the stance is not an object" };
+        case "plain":
+        case "array":
+            break;
+        case "non_plain_object":
+            if (typeof s === "function")
+                return { kind: "malformed", why: "the stance is not an object" }; // 函数不是对象表态(类实例是)
+            break;
+        default: {
+            const unhandled = stanceShape;
+            throw new Error(`stanceOf: unhandled shape ${String(unhandled)}`);
+        }
+    }
     const runs = typeof s.run === "function";
     const declines = Object.prototype.hasOwnProperty.call(s, "declined");
     // 与类型同律(两臂互斥):声明臂上出现实现臂的任一字段(`entry` / `run`)都算「既实现又声明」。
@@ -376,7 +413,7 @@ async function releaseViolations(adapter, opts, corpus, kit) {
             continue;
         }
         const cases = e.outcome.cases;
-        if (!Array.isArray(cases) || cases.length === 0)
+        if (!isJsonArray(cases) || cases.length === 0)
             v.push(`known divergence \`${name}\` is an outcome divergence that must name at least one case — 结局形不许按前缀大包一整条腿的拒绝面`);
     }
     // **每条腿都要表态**:实现,或显式声明不承担(闭集理由词 + why)。缺表态 / 形不对 ⇒ 违例 —— 不许静默跳过,也不许默认当通过。

package/dist/cross-session.d.ts

@@ -50,11 +50,11 @@ export type CrossSessionInboundValue = (typeof CROSS_SESSION_INBOUND_VALUES)[num
 export declare const CROSS_SESSION_INBOUND_UNSET: "default";
 /** 文件层受理面:四个显式值 + `"default"`(未设)。 */
 export declare const CrossSessionInboundSetting: z.ZodEnum<{
+    refuse: "refuse";
     default: "default";
     wake: "wake";
     "next-turn": "next-turn";
     hold: "hold";
-    refuse: "refuse";
 }>;
 export type CrossSessionInboundSettingValue = z.infer<typeof CrossSessionInboundSetting>;
 /** 四值闭集(CC 逐字)。`"never"` = 不设期限。 */
@@ -64,8 +64,8 @@ export type DialogExpiryValue = (typeof DIALOG_EXPIRY_VALUES)[number];
 export declare const DIALOG_EXPIRY_DEFAULT: DialogExpiryValue;
 /** 文件层受理面:四个值 + `"default"`(未设 ⇒ 落 {@link DIALOG_EXPIRY_DEFAULT})。 */
 export declare const DialogExpirySetting: z.ZodEnum<{
-    never: "never";
     default: "default";
+    never: "never";
     "60s": "60s";
     "5m": "5m";
     "10m": "10m";
@@ -78,15 +78,15 @@ export type DialogExpirySettingValue = z.infer<typeof DialogExpirySetting>;
  */
 export declare const CrossSessionSettings: z.ZodObject<{
     crossSessionInbound: z.ZodOptional<z.ZodEnum<{
+        refuse: "refuse";
         default: "default";
         wake: "wake";
         "next-turn": "next-turn";
         hold: "hold";
-        refuse: "refuse";
     }>>;
     dialogExpiry: z.ZodOptional<z.ZodEnum<{
-        never: "never";
         default: "default";
+        never: "never";
         "60s": "60s";
         "5m": "5m";
         "10m": "10m";