@sema-agent/settings-schema 14.6.0 → 14.8.0

package/dist/mcp-request-entry.d.ts

@@ -1,18 +1,20 @@
 import { type McpContentOrigin } from "./types.js";
-/** 值的**种类**(不回显值本身)。总(不抛):经 {@link inspectSafely}。 */
+/** 值的**种类**(不回显值本身)。总(不抛):形状只问座位,读不出的对象说全包唯一的「检视不了」那一句。 */
 export declare function describeValueShape(v: unknown): string;
-/** 「不是字符串数组」的种类:数组里混了非串元素说那一句,否则回落到 {@link describeValueShape}。总(不抛):经 {@link inspectSafely}。 */
+/** 「不是字符串数组」的种类:数组里混了非串元素说那一句,否则回落到 {@link describeValueShape}。总(不抛):`isJsonArray` 是座位的总版。 */
 export declare function describeNotStringArray(v: unknown): string;
-/** 「不是字符串值的对象」的种类:对象里混了非串值说那一句,否则回落到 {@link describeValueShape}。总(不抛):经 {@link inspectSafely}。 */
+/** 「不是字符串值的对象」的种类:对象里混了非串值说那一句,否则回落到 {@link describeValueShape}。总(不抛)。 */
 export declare function describeNotStringRecord(v: unknown): string;
 /**
- * 字符串数组(空数组合法)。与传输读器读 `args` 是**同一只读法**(`./definition-copy` 的 `captureStringArray`:按下标、自有下标、一次读、非串即坏、不走迭代协议):
- * 稀疏数组(洞)、`length` 读不出安全非负整数的数组、读元素时抛的数组都不是 —— 洞不顺原型链读到 `Object.prototype` / `Array.prototype` 上的数字键。
+ * 字符串数组(空数组合法)—— 类型守卫,所以按 `./own-key-read` 的 `captureStringArray` 的**严归类**读(整容器读,自有下标各一份描述符,非串即坏、不走迭代协议):
+ * 下标是访问器或不可枚举的数组不是(getter 一次都不调 —— 守卫为真,调用方随后的普通读读到的就是判过的那一份);稀疏数组(洞)、`length` 读不出安全非负整数的数组、
+ * 读不出的数组都不是 —— 洞不顺原型链读到 `Object.prototype` / `Array.prototype` 上的数字键。传输读器读 `args` 交出去的是副本,用同一只函数的宽归类。
  */
 export declare function isStringArray(v: unknown): v is string[];
 /**
- * 纯数据的「名 → 串」记录(空对象合法;数组、`Map`、类实例、自有 `__proto__` 成员、有非串成员的对象都不是)。与传输读器读 `env` / `headers` 是**同一个**定义
- * ({@link readPlainStringRecord}):包内没有第二把更宽的尺。
+ * 纯数据的「名 → 串」记录(空对象合法;数组、`Map`、类实例、自有 `__proto__` 成员、有非串成员的对象都不是)—— 类型守卫,所以是**严归类**:成员经内核的
+ * `ownEntriesOf` 读(整容器读的严归类:每个自有串键一份描述符;访问器成员或不可枚举的成员 ⇒ 不是,getter 一次都不调 —— 守卫为真,调用方随后的普通读读到的就是判过的那一份)。
+ * 传输读器读 `env` / `headers`({@link readPlainStringRecord})交出去的是**副本**,按宽归类读(不可枚举的成员照读、访问器调一次);值与成员名的判据(是串、不叫 `__proto__`)两边同一条。
  */
 export declare function isStringRecord(v: unknown): v is Record<string, string>;
 /** 引擎 `TOOL_WIRE_NAME_MAX_CHARS` 的镜像:一台 MCP server(或 A2A 对端)的申报名会成为线上工具名的命名空间段,引擎对超界名是**拒**(不截断)。 */
@@ -29,6 +31,16 @@ export declare function isUsableWireName(v: unknown): v is string;
  * (制表 / 换行这类控制空白在回显里被剥掉,所以看得出是空白靠这个种类词,不靠引号里的样子);两件事并存 ⇒ 一句说全(`N chars > 128, leading or trailing whitespace`)。
  */
 export declare function describeBadWireName(v: unknown): string;
+/**
+ * 这个 MCP 服务器名能用吗:{@link isUsableWireName} 再加一臂 —— 不在保留给设备执行端远程 MCP 服务器的 `remote-` 命名空间里(`./mcp-server-name`,字面前缀比较)。
+ * 只多这一臂:线上名的判据(非空、长界、首尾空白)一字不改,别的输入两只判官逐项同答。A2A 对端名只用 {@link isUsableWireName}(它的工具名前缀是 `a2a__`,不在这个命名空间里)。
+ */
+export declare function isUsableMcpServerName(v: unknown): v is string;
+/**
+ * 坏 MCP 服务器名的**可打印**摘要:线上名本身就坏 ⇒ 与 {@link describeBadWireName} 逐字同(长界这类线上名的事实先说,不被保留臂盖掉);
+ * 线上名好而落在保留命名空间里 ⇒ 引号形的回显加那一句原因。
+ */
+export declare function describeBadMcpServerName(v: unknown): string;
 /**
  * 在内容出处词表({@link MCP_CONTENT_ORIGINS})内吗。严判:非串与大小写不符(`"LOCAL"`)一律不在 —— 引擎的词是字面量联合、不做规范化;
  * 替它「宽容一下」等于自造第二份值域语义,而这条轴上宽容的方向恰好是**放宽信任**(把一个写坏的声明读成 `"local"`)。
@@ -44,7 +56,14 @@ export declare function readMcpIdentityHeaders(transport: Record<string, unknown
     principalHeader?: string;
     assertionHeader?: string;
 };
-/** 请求面一条 MCP 条目的传输形:引擎的传输形,http 形多一个承载的 `assertionHeader`(引擎的 http 传输没有这个座;交给引擎之前由消费方剥掉)。 */
+/**
+ * 请求面一条 MCP 条目的传输形。与引擎传输形的关系逐键一句(处置表,对拍 = 上游漂移门 ⑧):
+ *  · `kind` / `command` / `args` / `url` / `principalHeader` —— 与引擎同键同型;
+ *  · `env` / `headers` —— 请求带来的**字面件**:引擎的声明不带值(一台服务器的凭据头 / 子进程环境由部署的对端座每次发送时答),
+ *    所以这两把键交给引擎之前由消费方从声明里拿走、按它自己的对端座答;
+ *  · `assertionHeader` —— 本包承载,引擎的 http 传输没有这个座(交给引擎之前由消费方剥掉);
+ *  · 引擎的 `credentials`(不透明的凭据引用)—— 请求面不收:读器不读它。
+ */
 export type RequestMcpTransport = {
     kind: "stdio";
     command: string;
@@ -60,18 +79,18 @@ export type RequestMcpTransport = {
 /**
  * 条目内一处坏形:`path` = 条目内的键路径(`transport.url`),`reason` = 判官的原因句(只说形与词表,不回显值)。
  *
- * `env` / `headers` 这两张「名 → 串」记录上的坏形另带两格机读位,调用方分流不必解析句子:`fault` = 闭集词 ——
- *  · `not_plain_record`:这个键的值不是纯数据记录(不是对象 / 数组 / `null`,或不是朴素 JSON 对象 —— 原型链比座位的判据长:`Map`、`Set`、类实例);整张记录不交;
- *  · `member_not_string`:有一个成员的值不是串(或访问器抛了);整张记录不交,`member` 点名它;
+ * `env` / `headers` 这两张「名 → 串」记录上的坏形另带两格机读位,调用方分流不必解析句子:`fault` = 闭集词({@link PLAIN_STRING_RECORD_FAULTS},与公开的记录读器 {@link readPlainStringRecord} 同一张表)——
+ *  · `not_plain_record`:这个键的值不是纯数据记录(不是对象 / 数组 / `null`,或不是朴素 JSON 对象 —— 原型链比座位的判据长:`Map`、`Set`、类实例;读形状就抛的对象同);整张记录不交;
+ *  · `member_not_string`:有一个成员的值不是串,或它读不出(它的访问器抛了,或读它的描述符时代理陷阱抛了);整张记录不交,`member` 点名它,两种情形句子分说;
  *  · `member_name_reserved`:有一个成员叫 `__proto__`(引擎的声明收据拒这个名)。成员的值是串 ⇒ 只剔这个成员、其余照交,`path` 是成员级(`transport.env.__proto__`);
- *    成员的值也不是串 ⇒ 整张记录不交,`path` 是键级,句子一次说全两件事 —— 名坏优先、值坏并列,所以词仍是 `member_name_reserved`。
+ *    成员的值也不是串(或读不出)⇒ 整张记录不交,`path` 是键级,句子一次说全两件事 —— 名坏优先、值坏并列,所以词仍是 `member_name_reserved`。
  * `member` 是成员名的**回显形**(剥控制与双向字符、截 64 字加 `…`),可直接进日志与句子,不是回查原对象的键。其余的坏形(`args` / `url` / `principalHeader` / ……)两格都不带。
  */
 export interface McpEntryKeyIssue {
     readonly path: string;
     readonly reason: string;
     readonly member?: string;
-    readonly fault?: "not_plain_record" | "member_not_string" | "member_name_reserved";
+    readonly fault?: PlainStringRecordFault;
 }
 /** {@link readRequestMcpTransport} 的结果:`ok:false` = 硬坏形(这条 server 无从挂载);`ok:true` 的 `lost` = 读器**丢掉**的可选子键(server 照挂、少一个声明)。 */
 export type RequestMcpTransportRead = {
@@ -93,3 +112,38 @@ export type RequestMcpTransportRead = {
  * url 的拒句不回显值:它常规地带凭据(userinfo)。
  */
 export declare function readRequestMcpTransport(t: unknown): RequestMcpTransportRead;
+/**
+ * 引擎的声明收据不收的成员名(core `mcp-server-spec`:按赋值拷贝它会变成原型):JSON 文本铸得出这个**自有**键,对象字面量写不出。
+ * 公开,因为读器交出 `reservedMember: true` 时消费方要点名它 —— 名字只在这里定一次。
+ */
+export declare const PLAIN_STRING_RECORD_RESERVED_MEMBER = "__proto__";
+/**
+ * 「名 → 串」记录读不交(或交时点名保留名)的**原因词**,闭集,三个词、一张表:
+ * 整张一词(`not_plain_record`)· 成员级一词(`member_not_string`:值读成了别的种类,或读成员时抛了 —— 句子分说)· 名字级一词(`member_name_reserved`)。
+ * 词的意义逐词写在 {@link McpEntryKeyIssue}。消费方按词分派,不读句子;读器的读数 {@link PlainStringRecordRead} 与传输条目的机读位 {@link McpEntryKeyIssue} 的 `fault` 都由这一张表推出。
+ * 多一个词而消费方的穷尽 `switch` 不补 ⇒ 编译红(提货成本,不是静默)。
+ */
+export declare const PLAIN_STRING_RECORD_FAULTS: readonly ["not_plain_record", "member_not_string", "member_name_reserved"];
+export type PlainStringRecordFault = (typeof PLAIN_STRING_RECORD_FAULTS)[number];
+/**
+ * {@link readPlainStringRecord} 的读数:`ok:false` = 记录不交(`fault` = 原因词;`detail` 是接在 `must be a plain object of string values — ` 后面的句子;坏在某个成员时 `member` 点名它的回显形);
+ * `ok:true` = 交出去的纯数据副本,`reservedMember` = 记录里有一个名叫 {@link PLAIN_STRING_RECORD_RESERVED_MEMBER} 的成员(它没进副本)。
+ */
+export type PlainStringRecordRead = {
+    readonly ok: true;
+    readonly record: Record<string, string>;
+    readonly reservedMember: boolean;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+    readonly fault: PlainStringRecordFault;
+    readonly member?: string;
+};
+/**
+ * 读一份「名 → 串」记录 —— **公开读口**:传输读器读 `env` / `headers` 用的就是它,消费方读自己的「名 → 串」记录(中心名册的引用表)调同一只,不抄镜像。从不抛。记录交不交:是朴素 JSON 对象(座位的判据,见 `./plain-json-object`:原型是 `null`,或原型自己的原型是 `null`;纯数据 —— `Map`、`Set`、类实例、建在原型上的记录都不是),
+ * 且每个成员的值都是串。成员 = `Object.getOwnPropertyNames` 的每一个名字(不可枚举的也算 —— 引擎的收据按全部自有属性名读),值经内核 `readKey` 读(一份描述符:数据属性取值,访问器调一次,不问 `get` 陷阱;访问器或描述符 trap 抛了同判为坏 —— 词与「值不是串」同是 `member_not_string`,句子说读不出)。
+ * 读原型与成员名时代理 trap 抛了 ⇒ 整张不交(读器对调用方递来的任何对象都不抛;`JSON` 存体里不会有代理,这条只落在直接调读器的嵌入方身上)。
+ * 交出去的是副本(原型 `Object.prototype`、成员全可枚举),调用方的对象不被交出去、也不被改;名叫 `__proto__` 的成员不进副本,`reservedMember` 记下它。
+ * 名叫 `__proto__` 而值也坏的成员,句子一次说全两件事(名坏在前、值坏并列):调用方照值改完再撞第二条是两步才改对。
+ */
+export declare function readPlainStringRecord(v: unknown): PlainStringRecordRead;

package/dist/mcp-request-entry.js

@@ -14,78 +14,93 @@
  *
  * ## 依赖的引擎事实(镜像 + 漂移门)
  *  · 申报名的线长界 {@link TOOL_WIRE_NAME_MAX_CHARS} = 引擎同名常量(值级对拍:上游漂移门 ⑧);
- *  · 请求面传输形 {@link RequestMcpTransport} = 引擎 MCP 条目的传输形,http 形多一个本包承载的 `assertionHeader`(编译期双向对拍:门 ⑧);
+ *  · 请求面传输形 {@link RequestMcpTransport} 对引擎 MCP 条目的传输形是一张处置表,两边每个键恰好一行(编译期两向对拍:门 ⑧)——
+ *    `kind` / `command` / `args` / `url` / `principalHeader` 与引擎同键同型;`env` / `headers` 是请求带来的字面件(引擎的声明不带值);
+ *    `assertionHeader` 本包承载(引擎没有这个座);引擎的 `credentials`(不透明的凭据引用)请求面不收;
  *  · 内容出处词表 = {@link MCP_CONTENT_ORIGINS}(已有的镜像,门 ⑥);
  *  · url 前缀守卫 = `./url-shape` 的 `startsWithHttpScheme`(本包判 URL 的正则只在那一个模块)。它只看前缀,不是形判官 —— 同一个串两口可以答得不同,两张分歧表与收口形(S-2106)写在 `./url-shape` 头注「第二个答案」。
  *
  * ## 与配置面的关系(如实)
  * 配置面的 MCP 条目(`McpServerSpec`,部署声明:凭据只许 env-NAME 引用)与请求面(提交体:可带字面凭据 `env` / `headers`)是两份契约,本模块只管后者。
  * 两份契约对「名」与「url」今天给的判据不同(配置面:名按字符集、url 按 `NON_SECRET_URL`;请求面:名按长度界、url 按 http(s) 前缀),本版刻意不动
- * (语义逐字搬),是一项已知待收的分歧。
+ * (语义逐字搬),是一项已知待收的分歧。`remote-` 保留前缀这一臂也只在请求面(`isUsableMcpServerName`):配置面 `McpServerSpec.name` 不拒它(此前合法的名被拒是校验收紧,归 major,不在 minor 里落),是又一处两面不齐的已知分歧。
  */
 import { echoCallerText } from "./caller-text-echo.js";
-import { captureStringArray, dataDescriptor } from "./definition-copy.js";
-import { isPlainJsonObject, jsonShapeOf } from "./plain-json-object.js";
+import { UNINSPECTABLE, captureStringArray, dataDescriptor, inspect, ownEntriesOf, ownFieldsOf, ownValueOf, readKey } from "./own-key-read.js";
+import { isJsonArray, isPlainJsonObject, jsonShapeOf } from "./plain-json-object.js";
 import { MCP_CONTENT_ORIGINS } from "./types.js";
+import { RESERVED_MCP_SERVER_NAME_REASON, isReservedMcpServerName } from "./mcp-server-name.js";
 import { startsWithHttpScheme } from "./url-shape.js";
 // ── 值的种类描述(拒句只说「你写的是什么形」,不回显值:值可能带凭据、可能任意长)──────────────────────────────────────
-/** 撤销 / 读不出的 Proxy 的拒句(`got ` 之后的名词短语)—— **全包唯一的一句**:`Array.isArray` 对已撤销的 Proxy 抛 `TypeError`,陷阱抛出来也一样,读器与描述器都不能因此被带出去。 */
-const UNINSPECTABLE = "an object that could not be inspected (a proxy trap threw)";
-/**
- * 唯一的**安全检视内核**:读器与描述器要碰不可信的值(`Array.isArray` 对已撤销的 Proxy 抛、`get` / 原型陷阱抛、会抛的自有 getter)都经它 ——
- * 「检视不了」的**律与句都单源**:抛了 ⇒ `ok:false` 带 {@link UNINSPECTABLE} 那一句,不再各处各包一个 try、各写一句。
- */
-function inspect(read) {
-    try {
-        return { ok: true, value: read() };
-    }
-    catch {
-        return { ok: false, sentence: UNINSPECTABLE };
+/** 值的**种类词**(不回显值本身):`null` / `array` / `typeof` 词(`object` / `function` / `string` …);读不出的对象 ⇒ 全包唯一的那一句。形状只问座位(总,不抛):两只坏值描述器共用这一只。 */
+function describeKindWord(v) {
+    const shape = jsonShapeOf(v);
+    switch (shape) {
+        case "null":
+            return "null";
+        case "array":
+            return "array";
+        case "uninspectable":
+            return UNINSPECTABLE;
+        case "plain":
+        case "non_plain_object":
+        case "primitive":
+            return typeof v;
+        default: {
+            const unhandled = shape;
+            throw new Error(`describeKindWord: unhandled shape ${String(unhandled)}`);
+        }
     }
 }
-/** 三只描述器的壳:检视抛了就说「检视不了」那一句(经 {@link inspect})。 */
-function inspectSafely(describe) {
-    const read = inspect(describe);
-    return read.ok ? read.value : read.sentence;
-}
-/** 值的**种类**(不回显值本身)。总(不抛):经 {@link inspectSafely}。 */
+/** 值的**种类**(不回显值本身)。总(不抛):形状只问座位,读不出的对象说全包唯一的「检视不了」那一句。 */
 export function describeValueShape(v) {
-    return inspectSafely(() => {
-        if (v === undefined)
-            return "nothing (the key is absent)";
-        if (v === null)
+    if (v === undefined)
+        return "nothing (the key is absent)";
+    const shape = jsonShapeOf(v);
+    switch (shape) {
+        case "null":
             return "null";
-        if (Array.isArray(v))
+        case "array":
             return "an array";
-        if (typeof v === "string")
-            return v.length === 0 ? "an empty string" : `a string of ${v.length} characters`;
-        if (typeof v === "object")
-            return "an object";
-        return `a ${typeof v}`;
-    });
+        case "uninspectable":
+            return UNINSPECTABLE;
+        case "plain":
+        case "non_plain_object":
+            return typeof v === "function" ? "a function" : "an object";
+        case "primitive":
+            return typeof v === "string" ? (v.length === 0 ? "an empty string" : `a string of ${v.length} characters`) : `a ${typeof v}`;
+        default: {
+            const unhandled = shape;
+            throw new Error(`describeValueShape: unhandled shape ${String(unhandled)}`);
+        }
+    }
 }
-/** 「不是字符串数组」的种类:数组里混了非串元素说那一句,否则回落到 {@link describeValueShape}。总(不抛):经 {@link inspectSafely}。 */
+/** 「不是字符串数组」的种类:数组里混了非串元素说那一句,否则回落到 {@link describeValueShape}。总(不抛):`isJsonArray` 是座位的总版。 */
 export function describeNotStringArray(v) {
-    return inspectSafely(() => (Array.isArray(v) ? "an array with a non-string element" : describeValueShape(v)));
+    return isJsonArray(v) ? "an array with a non-string element" : describeValueShape(v);
 }
-/** 「不是字符串值的对象」的种类:对象里混了非串值说那一句,否则回落到 {@link describeValueShape}。总(不抛):经 {@link inspectSafely}。 */
+/** 「不是字符串值的对象」的种类:对象里混了非串值说那一句,否则回落到 {@link describeValueShape}。总(不抛)。 */
 export function describeNotStringRecord(v) {
-    return inspectSafely(() => (isPlainJsonObject(v) ? "an object with a non-string value" : describeValueShape(v)));
+    return isPlainJsonObject(v) ? "an object with a non-string value" : describeValueShape(v);
 }
 /**
- * 字符串数组(空数组合法)。与传输读器读 `args` 是**同一只读法**(`./definition-copy` 的 `captureStringArray`:按下标、自有下标、一次读、非串即坏、不走迭代协议):
- * 稀疏数组(洞)、`length` 读不出安全非负整数的数组、读元素时抛的数组都不是 —— 洞不顺原型链读到 `Object.prototype` / `Array.prototype` 上的数字键。
+ * 字符串数组(空数组合法)—— 类型守卫,所以按 `./own-key-read` 的 `captureStringArray` 的**严归类**读(整容器读,自有下标各一份描述符,非串即坏、不走迭代协议):
+ * 下标是访问器或不可枚举的数组不是(getter 一次都不调 —— 守卫为真,调用方随后的普通读读到的就是判过的那一份);稀疏数组(洞)、`length` 读不出安全非负整数的数组、
+ * 读不出的数组都不是 —— 洞不顺原型链读到 `Object.prototype` / `Array.prototype` 上的数字键。传输读器读 `args` 交出去的是副本,用同一只函数的宽归类。
  */
 export function isStringArray(v) {
-    return captureStringArray(v) !== undefined;
+    return captureStringArray(v, "strict") !== undefined;
 }
 /**
- * 纯数据的「名 → 串」记录(空对象合法;数组、`Map`、类实例、自有 `__proto__` 成员、有非串成员的对象都不是)。与传输读器读 `env` / `headers` 是**同一个**定义
- * ({@link readPlainStringRecord}):包内没有第二把更宽的尺。
+ * 纯数据的「名 → 串」记录(空对象合法;数组、`Map`、类实例、自有 `__proto__` 成员、有非串成员的对象都不是)—— 类型守卫,所以是**严归类**:成员经内核的
+ * `ownEntriesOf` 读(整容器读的严归类:每个自有串键一份描述符;访问器成员或不可枚举的成员 ⇒ 不是,getter 一次都不调 —— 守卫为真,调用方随后的普通读读到的就是判过的那一份)。
+ * 传输读器读 `env` / `headers`({@link readPlainStringRecord})交出去的是**副本**,按宽归类读(不可枚举的成员照读、访问器调一次);值与成员名的判据(是串、不叫 `__proto__`)两边同一条。
  */
 export function isStringRecord(v) {
-    const read = readPlainStringRecord(v);
-    return read.ok && !read.reservedMember;
+    if (!isPlainJsonObject(v))
+        return false;
+    const entries = ownEntriesOf(v);
+    return entries.ok && entries.value.every(([name, value]) => name !== PLAIN_STRING_RECORD_RESERVED_MEMBER && typeof value === "string");
 }
 // ── 调用方写的串的回显口径 ──────────────────────────────────────────────────────────────────────────
 /** 句子里点名一个值的写法:{@link echoCallerText} 外加一对双引号;内部的引号与反斜杠逐字(不转义)。 */
@@ -115,7 +130,7 @@ export function isUsableWireName(v) {
  */
 export function describeBadWireName(v) {
     if (typeof v !== "string")
-        return v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+        return describeKindWord(v);
     if (v.length === 0)
         return "empty";
     const head = quotedCallerText(v);
@@ -124,6 +139,23 @@ export function describeBadWireName(v) {
         return `${head} (${tooLong})`;
     return `${head} (${v.length > TOOL_WIRE_NAME_MAX_CHARS ? `${tooLong}, ` : ""}leading or trailing whitespace)`;
 }
+// ── MCP 服务器名(线上名 + 保留命名空间)──────────────────────────────────────────────────────────────────
+/**
+ * 这个 MCP 服务器名能用吗:{@link isUsableWireName} 再加一臂 —— 不在保留给设备执行端远程 MCP 服务器的 `remote-` 命名空间里(`./mcp-server-name`,字面前缀比较)。
+ * 只多这一臂:线上名的判据(非空、长界、首尾空白)一字不改,别的输入两只判官逐项同答。A2A 对端名只用 {@link isUsableWireName}(它的工具名前缀是 `a2a__`,不在这个命名空间里)。
+ */
+export function isUsableMcpServerName(v) {
+    return isUsableWireName(v) && !isReservedMcpServerName(v);
+}
+/**
+ * 坏 MCP 服务器名的**可打印**摘要:线上名本身就坏 ⇒ 与 {@link describeBadWireName} 逐字同(长界这类线上名的事实先说,不被保留臂盖掉);
+ * 线上名好而落在保留命名空间里 ⇒ 引号形的回显加那一句原因。
+ */
+export function describeBadMcpServerName(v) {
+    if (!isUsableWireName(v))
+        return describeBadWireName(v);
+    return `${quotedCallerText(v)} (${RESERVED_MCP_SERVER_NAME_REASON})`;
+}
 // ── 内容出处词 ──────────────────────────────────────────────────────────────────────────────────────
 const CONTENT_ORIGIN_WORDS = new Set(MCP_CONTENT_ORIGINS);
 /**
@@ -135,7 +167,7 @@ export function isContentOriginWord(v) {
 }
 /** 坏内容出处值的**可打印**摘要:串 ⇒ 引号形的回显({@link quotedCallerText}:剥控制与双向字符、截 64 字);非串只说种类。 */
 export function describeBadContentOrigin(v) {
-    return typeof v === "string" ? quotedCallerText(v) : v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+    return typeof v === "string" ? quotedCallerText(v) : describeKindWord(v);
 }
 // ── 两个身份头 ──────────────────────────────────────────────────────────────────────────────────────
 /**
@@ -155,35 +187,35 @@ export function readMcpIdentityHeaders(transport) {
 /**
  * 两个身份头的**唯一读法**(公开读者与传输快照共用):只有 `principalHeader` **干净地读成缺席**时才读 `assertionHeader`;`principalHeader` 在场(不论值形)⇒ `assertionHeader` 一次不读;
  * 任何一个读不出 ⇒ 整体读不出(`ok:false`,向上传),不折成 `undefined` —— 不然「principal 读不出」会落到 assertion、读它的 getter。
+ * **只读自有键**(身份只认自有键):键只靠继承可见(含 `Object.prototype` 被污染成数据值)⇒ 不读它的值、当缺席,但**记下**(`principalInherited` / `assertionInherited`)—— 传输读器据此点名,
+ * 身份轴上不静默;公开读者没有 `lost` 通道,只读值。
  */
 function identityFieldsOf(record) {
-    const principal = ownValueOf(record, "principalHeader");
-    if (!principal.ok)
-        return principal;
-    if (principal.value !== undefined)
-        return { ok: true, value: { principalHeader: principal.value, assertionHeader: undefined } };
-    const assertion = ownValueOf(record, "assertionHeader");
-    if (!assertion.ok)
-        return assertion;
-    return { ok: true, value: { principalHeader: undefined, assertionHeader: assertion.value } };
-}
-/** 一个字段的值,**只读自有属性**(`Object.hasOwn`):原型链上的值 / 被污染的 getter 一律当缺席。**自身就是守护读**(经 `inspect`):`getOwnPropertyDescriptor` 陷阱抛、会抛的自有 getter、
- *  已撤销的 Proxy ⇒ `ok:false`(读不出),调用方各自决定怎么办、不再各包一层。 */
-function ownValueOf(record, key) {
-    return inspect(() => (Object.hasOwn(record, key) ? record[key] : undefined));
-}
-/** 按顺序读若干字段,**第一个读不出的就停**(后面的一个不读),整体读不出向上传。 */
-function ownFieldsOf(record, keys) {
-    const out = Object.create(null);
-    for (const key of keys) {
-        const read = ownValueOf(record, key);
-        if (!read.ok)
-            return read;
-        Object.defineProperty(out, key, dataDescriptor(read.value));
+    const principal = readKey(record, "principalHeader");
+    if (principal.presence === "unreadable")
+        return { ok: false, sentence: UNINSPECTABLE };
+    if (principal.presence === "own" && principal.value !== undefined) {
+        return { ok: true, value: { principalHeader: principal.value, assertionHeader: undefined, principalInherited: false, assertionInherited: false } };
     }
-    return { ok: true, value: out };
+    const assertion = readKey(record, "assertionHeader");
+    if (assertion.presence === "unreadable")
+        return { ok: false, sentence: UNINSPECTABLE };
+    return {
+        ok: true,
+        value: {
+            principalHeader: undefined,
+            assertionHeader: assertion.presence === "own" ? assertion.value : undefined,
+            principalInherited: principal.presence === "inherited",
+            assertionInherited: assertion.presence === "inherited",
+        },
+    };
 }
 const transportBad = (path, reason) => ({ ok: false, issue: { path, reason } });
+/** 身份头只靠继承可见时的 `lost` 条目:不读它的值,但点名(身份轴不静默;句子不回显值)。机读位不带(`fault` 的闭集不为它加词)。 */
+const inheritedIdentityIssue = (key) => ({
+    path: `transport.${key}`,
+    reason: "inherited key ignored (the key is visible only through the prototype chain; a transport's identity headers are read from its own keys)",
+});
 /**
  * 请求面 `transport` 的**唯一读器**:读器投影 transport 用它,发送前 / 受理时的判形读它报的 `lost` —— 同一只函数两个消费点,「读器丢了什么」与「门拒什么」不可能分岔。
  *  · 硬坏形(`transport` 不是对象 / `kind` 出闭集 / stdio 缺 `command` / http 的 `url` 不是 http(s))⇒ `ok:false`,`path` 是读器点名的键路径;
@@ -214,7 +246,7 @@ export function readRequestMcpTransport(t) {
         }
     }
     const tr = t;
-    // 字段只读一次:同一个检视里把「这一种传输要读的字段」读成局部快照(`get` 陷阱抛的 Proxy / 会抛的自有 getter ⇒ 整只不交,不抛),之后只读快照;这一种传输用不到的字段一次也不读
+    // 字段只读一次:经读内核把「这一种传输要读的字段」读成局部快照(描述符 / `has` 陷阱抛的 Proxy / 会抛的自有 getter ⇒ 整只不交,不抛;`get` 陷阱不被问),之后只读快照;这一种传输用不到的字段一次也不读
     const snapshotRead = snapshotTransport(tr);
     if (!snapshotRead.ok)
         return transportBad("transport", `must be an object with a "kind" of "stdio" or "http" — got ${snapshotRead.sentence}`);
@@ -225,7 +257,7 @@ export function readRequestMcpTransport(t) {
             if (typeof snap.command !== "string" || snap.command.length === 0)
                 return transportBad("transport.command", `must be a non-empty string (the command to run) — got ${describeValueShape(snap.command)}`);
             const rawArgs = snap.args; // 交出去的是副本(不是调用方数组的原引用),稀疏 / 读不出的数组整键丢、进 `lost`
-            const args = rawArgs === undefined ? undefined : captureStringArray(rawArgs);
+            const args = rawArgs === undefined ? undefined : captureStringArray(rawArgs, "wide");
             const argsIssue = rawArgs !== undefined && args === undefined ? { path: "transport.args", reason: `must be an array of strings — got ${describeNotStringArray(rawArgs)}` } : undefined;
             const env = readTransportRecord("transport.env", snap.env);
             return {
@@ -256,7 +288,7 @@ export function readRequestMcpTransport(t) {
                     ...(headers.record !== undefined ? { headers: headers.record } : {}),
                     ...ids,
                 },
-                lost: issuesOf(...headers.issues, principalIssue),
+                lost: issuesOf(...headers.issues, principalIssue, snap.principalInherited ? inheritedIdentityIssue("principalHeader") : undefined, snap.assertionInherited ? inheritedIdentityIssue("assertionHeader") : undefined),
             };
         }
         case "other":
@@ -286,14 +318,24 @@ function snapshotTransport(tr) {
         const ids = identityFieldsOf(tr);
         if (!ids.ok)
             return ids;
-        return { ok: true, value: { kind: "http", url: fields.value.url, headers: fields.value.headers, principalHeader: ids.value.principalHeader, assertionHeader: ids.value.assertionHeader } };
+        return { ok: true, value: { kind: "http", url: fields.value.url, headers: fields.value.headers, principalHeader: ids.value.principalHeader, assertionHeader: ids.value.assertionHeader, principalInherited: ids.value.principalInherited, assertionInherited: ids.value.assertionInherited } };
     }
     return { ok: true, value: { kind: "other", value: kind.value } };
 }
 // ── 「名 → 串」记录的读法(`env` / `headers`)────────────────────────────────────────────────────────
-/** 引擎的声明收据不收的成员名(core `mcp-server-spec`:按赋值拷贝它会变成原型):JSON 文本铸得出这个**自有**键,对象字面量写不出。 */
-const RESERVED_MEMBER_NAME = "__proto__";
-const RESERVED_MEMBER_FAULT = `no member of a declaration may be named "${RESERVED_MEMBER_NAME}"`;
+/**
+ * 引擎的声明收据不收的成员名(core `mcp-server-spec`:按赋值拷贝它会变成原型):JSON 文本铸得出这个**自有**键,对象字面量写不出。
+ * 公开,因为读器交出 `reservedMember: true` 时消费方要点名它 —— 名字只在这里定一次。
+ */
+export const PLAIN_STRING_RECORD_RESERVED_MEMBER = "__proto__";
+const RESERVED_MEMBER_FAULT = `no member of a declaration may be named "${PLAIN_STRING_RECORD_RESERVED_MEMBER}"`;
+/**
+ * 「名 → 串」记录读不交(或交时点名保留名)的**原因词**,闭集,三个词、一张表:
+ * 整张一词(`not_plain_record`)· 成员级一词(`member_not_string`:值读成了别的种类,或读成员时抛了 —— 句子分说)· 名字级一词(`member_name_reserved`)。
+ * 词的意义逐词写在 {@link McpEntryKeyIssue}。消费方按词分派,不读句子;读器的读数 {@link PlainStringRecordRead} 与传输条目的机读位 {@link McpEntryKeyIssue} 的 `fault` 都由这一张表推出。
+ * 多一个词而消费方的穷尽 `switch` 不补 ⇒ 编译红(提货成本,不是静默)。
+ */
+export const PLAIN_STRING_RECORD_FAULTS = ["not_plain_record", "member_not_string", "member_name_reserved"];
 /** 记录不交时 `detail` 的前半句:它是哪一种不朴素(null / 数组 / 原始值各一句,对象里的非朴素一句)。`shape` 穷举 —— 新词不补 = 编译红。 */
 function notPlainDetail(shape, v) {
     switch (shape) {
@@ -316,13 +358,13 @@ function notPlainDetail(shape, v) {
     }
 }
 /**
- * 读一份「名 → 串」记录。记录交不交:是朴素 JSON 对象(座位的判据,见 `./plain-json-object`:原型是 `null`,或原型自己的原型是 `null`;纯数据 —— `Map`、`Set`、类实例、建在原型上的记录都不是),
- * 且每个成员的值都是串。成员 = `Object.getOwnPropertyNames` 的每一个名字(不可枚举的也算 —— 引擎的收据按全部自有属性名读),值按属性描述读:数据属性取值,访问器调一次(访问器或描述 trap 抛了同判为坏)。
+ * 读一份「名 → 串」记录 —— **公开读口**:传输读器读 `env` / `headers` 用的就是它,消费方读自己的「名 → 串」记录(中心名册的引用表)调同一只,不抄镜像。从不抛。记录交不交:是朴素 JSON 对象(座位的判据,见 `./plain-json-object`:原型是 `null`,或原型自己的原型是 `null`;纯数据 —— `Map`、`Set`、类实例、建在原型上的记录都不是),
+ * 且每个成员的值都是串。成员 = `Object.getOwnPropertyNames` 的每一个名字(不可枚举的也算 —— 引擎的收据按全部自有属性名读),值经内核 `readKey` 读(一份描述符:数据属性取值,访问器调一次,不问 `get` 陷阱;访问器或描述符 trap 抛了同判为坏 —— 词与「值不是串」同是 `member_not_string`,句子说读不出)。
  * 读原型与成员名时代理 trap 抛了 ⇒ 整张不交(读器对调用方递来的任何对象都不抛;`JSON` 存体里不会有代理,这条只落在直接调读器的嵌入方身上)。
  * 交出去的是副本(原型 `Object.prototype`、成员全可枚举),调用方的对象不被交出去、也不被改;名叫 `__proto__` 的成员不进副本,`reservedMember` 记下它。
  * 名叫 `__proto__` 而值也坏的成员,句子一次说全两件事(名坏在前、值坏并列):调用方照值改完再撞第二条是两步才改对。
  */
-function readPlainStringRecord(v) {
+export function readPlainStringRecord(v) {
     // 形状归座位旁的分类(不在这里再推一遍;座位总 —— 读形状就抛的对象答 `uninspectable`)。成员名的读取(`ownKeys` 陷阱抛)读不出的对象也不是纯数据。
     // 读器不抛出去 —— 重放存量提交体的腿被一次抛错砖死比整键不交糟,而「整键不交」是响亮的(进 `lost`)。检视律与句都在 `inspect`。
     const shape = jsonShapeOf(v);
@@ -337,26 +379,23 @@ function readPlainStringRecord(v) {
     const members = Object.create(null);
     let reservedMember = false;
     for (const name of names) {
-        let value;
-        let unreadable = false;
-        try {
-            const d = Object.getOwnPropertyDescriptor(v, name);
-            value = d === undefined ? undefined : Object.hasOwn(d, "value") ? d.value : d.get === undefined ? undefined : Reflect.apply(d.get, v, []);
-        }
-        catch {
-            unreadable = true;
-        }
+        // 成员经内核读(契约见函数头注):一份描述符里取值 —— 数据属性取值、访问器调一次、从不问 Proxy 的 `get` 陷阱;成员在两次读之间被删掉 ⇒ 不是串(不读继承来的值)
+        const read = readKey(v, name);
+        const unreadable = read.presence === "unreadable";
+        const value = read.presence === "own" ? read.value : undefined;
         if (unreadable || typeof value !== "string") {
             const valueFault = unreadable ? "could not be read (its getter threw)" : `must be a string — got ${describeValueShape(value)}`;
-            const reserved = name === RESERVED_MEMBER_NAME;
+            const reserved = name === PLAIN_STRING_RECORD_RESERVED_MEMBER;
+            // 词:名坏优先(句子里值坏并列说全);名没问题时,读不出与值不是串同词,句子分说
+            const fault = reserved ? "member_name_reserved" : "member_not_string";
             return {
                 ok: false,
-                fault: reserved ? "member_name_reserved" : "member_not_string",
+                fault,
                 member: echoCallerText(name),
                 detail: `its member "${echoCallerText(name)}" ${reserved ? `is not allowed (${RESERVED_MEMBER_FAULT}) and its value ${valueFault}` : valueFault}`,
             };
         }
-        if (name === RESERVED_MEMBER_NAME)
+        if (name === PLAIN_STRING_RECORD_RESERVED_MEMBER)
             reservedMember = true;
         else
             Object.defineProperty(members, name, dataDescriptor(value));
@@ -381,6 +420,6 @@ function readTransportRecord(path, raw) {
     }
     return {
         record: read.record,
-        issues: read.reservedMember ? [{ path: `${path}.${RESERVED_MEMBER_NAME}`, reason: RESERVED_MEMBER_FAULT, member: RESERVED_MEMBER_NAME, fault: "member_name_reserved" }] : [],
+        issues: read.reservedMember ? [{ path: `${path}.${PLAIN_STRING_RECORD_RESERVED_MEMBER}`, reason: RESERVED_MEMBER_FAULT, member: PLAIN_STRING_RECORD_RESERVED_MEMBER, fault: "member_name_reserved" }] : [],
     };
 }

package/dist/mcp-server-name.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MCP 服务器名的保留命名空间 —— 一处定义,请求面的 MCP 名判官(`isUsableMcpServerName` / `describeBadMcpServerName`)读同一个谓词、说同一句原因。
+ * 配置面 `McpServerSpec.name` **不读**它(受理以这个前缀起头的名):此前合法的名被拒是校验收紧,按发版纪律归 major。
+ * 纯数据 + 纯函数,浏览器安全(叶模块:不 import 本包别的模块)。
+ *
+ * 设备执行端(device executor)提供的远程 MCP 服务器以 `remote-<名>` 挂载,工具名 `mcp__remote-<名>__<工具>`。部署声明的、请求带来的 MCP 条目若也用这个前缀,
+ * 一台它们声明的服务器就与一台设备上的服务器同名、落进同一个工具名命名空间 —— 所以这个前缀只归设备挂载。
+ *
+ * 比较按**字面**(区分大小写、不规范化):引擎铸工具名前缀时保留大小写、只把 `[A-Za-z0-9_-]` 之外的字符换成 `_`,`remote-` 这七个字符原样保留 ——
+ * 所以「名字以 `remote-` 起头」恰好等于「铸出的命名空间段以 `remote-` 起头」;`Remote-x` 铸成 `mcp__Remote-x__`,不在这个命名空间里。
+ */
+/** 保留给设备执行端远程 MCP 服务器的名字前缀(挂载名 = 这个前缀 + 设备声明的服务器名)。 */
+export declare const REMOTE_MCP_SERVER_NAME_PREFIX = "remote-";
+/** 这个 MCP 服务器名落在保留命名空间里吗(字面前缀比较)。 */
+export declare function isReservedMcpServerName(name: string): boolean;
+/** 保留前缀的原因句(不回显名字 —— 回显由读它的那一面按自己的口径加)。 */
+export declare const RESERVED_MCP_SERVER_NAME_REASON = "the \"remote-\" prefix is reserved for the remote MCP servers a device executor offers";

package/dist/mcp-server-name.js

@@ -0,0 +1,19 @@
+/**
+ * MCP 服务器名的保留命名空间 —— 一处定义,请求面的 MCP 名判官(`isUsableMcpServerName` / `describeBadMcpServerName`)读同一个谓词、说同一句原因。
+ * 配置面 `McpServerSpec.name` **不读**它(受理以这个前缀起头的名):此前合法的名被拒是校验收紧,按发版纪律归 major。
+ * 纯数据 + 纯函数,浏览器安全(叶模块:不 import 本包别的模块)。
+ *
+ * 设备执行端(device executor)提供的远程 MCP 服务器以 `remote-<名>` 挂载,工具名 `mcp__remote-<名>__<工具>`。部署声明的、请求带来的 MCP 条目若也用这个前缀,
+ * 一台它们声明的服务器就与一台设备上的服务器同名、落进同一个工具名命名空间 —— 所以这个前缀只归设备挂载。
+ *
+ * 比较按**字面**(区分大小写、不规范化):引擎铸工具名前缀时保留大小写、只把 `[A-Za-z0-9_-]` 之外的字符换成 `_`,`remote-` 这七个字符原样保留 ——
+ * 所以「名字以 `remote-` 起头」恰好等于「铸出的命名空间段以 `remote-` 起头」;`Remote-x` 铸成 `mcp__Remote-x__`,不在这个命名空间里。
+ */
+/** 保留给设备执行端远程 MCP 服务器的名字前缀(挂载名 = 这个前缀 + 设备声明的服务器名)。 */
+export const REMOTE_MCP_SERVER_NAME_PREFIX = "remote-";
+/** 这个 MCP 服务器名落在保留命名空间里吗(字面前缀比较)。 */
+export function isReservedMcpServerName(name) {
+    return name.startsWith(REMOTE_MCP_SERVER_NAME_PREFIX);
+}
+/** 保留前缀的原因句(不回显名字 —— 回显由读它的那一面按自己的口径加)。 */
+export const RESERVED_MCP_SERVER_NAME_REASON = `the "${REMOTE_MCP_SERVER_NAME_PREFIX}" prefix is reserved for the remote MCP servers a device executor offers`;

package/dist/migration-receipt.d.ts

@@ -2,11 +2,12 @@
  * 一次性迁移的**收据形**与两张闭集(11.0.0)—— 叶子模块(运行期零依赖;只有型导入),由 `./one-time-migrations` 再导出(不进主桶)。
  * 单拆出来只为一件事:调度店的读口(`./scheduler-store`,轻、浏览器安全)要在告警里带收据,不该为一个型把整套域 schema 拉进来。
  */
+import type { ENV_MODELS_DOCUMENT } from "./config-root-documents.js";
 import type { REMOTE_EXEC_DOCUMENT } from "./remote-exec.js";
 import type { DomainName, RetiredDomainName } from "./types.js";
 /** 本版登记的一次性**数据**迁移 id(闭集;每个 id 在 `ONE_TIME_MIGRATIONS` 登记表里恰一行)。收据只许这些 id —— 同表登记的 wire 删码位
  *  (`WIRE_RETIREMENT_IDS`,`./one-time-migrations`)不改任何存储形,铸不出收据,不在本集。 */
-export declare const ONE_TIME_MIGRATION_IDS: readonly ["SS-M1", "SS-M2", "SS-M3", "SS-M4", "SS-M5", "SS-M6", "SS-M7", "SS-M8", "SS-M9", "SS-M10"];
+export declare const ONE_TIME_MIGRATION_IDS: readonly ["SS-M1", "SS-M2", "SS-M3", "SS-M4", "SS-M5", "SS-M6", "SS-M7", "SS-M8", "SS-M9", "SS-M10", "SS-M11"];
 export type OneTimeMigrationId = (typeof ONE_TIME_MIGRATION_IDS)[number];
 /**
  * 一条收据说迁移**对一个坐标做了什么**(闭集,每词一义):
@@ -14,12 +15,15 @@ export type OneTimeMigrationId = (typeof ONE_TIME_MIGRATION_IDS)[number];
  *  - `rewritten`        — 同一坐标上的值换成今天的生效读法(例:URL 剥掉从不上线的 fragment、调度行的 durable 键重铸、6.x 的 worker 行换新形);
  *  - `dropped-shadowed` — 删掉;它从来没生效过,因为另一个位赢了(例:`governance` 已设时 `runtime` 上的治理旧键、`sealedApiKey` 在场时的 `apiKeyEnv`);
  *  - `dropped-inert`    — 删掉;今天的读法本就不让它生效(例:超界的主机条目、引擎从不读的旧字段、空的retired 域文档);
- *  - `refused`          — 不改:要改就得替运维猜(或旧文档今天本就读不进);原样留着,读侧照旧响亮拒,`reason` 说为什么。
+ *  - `refused`          — 不改:要改就得替运维猜(或旧文档今天本就读不进);原样留着,读侧照旧响亮拒,`reason` 说为什么;
+ *  - `minted`           — 在**缺席处**写下一份新事实(一份部署决定),不改任何已有的值 —— 只有 SS-M11 铸(配置根的 `config.env-models.json`:
+ *                         升级前「管模型面的目录整表顶替 env 模型」的读法,写成 `replaced`;不存在才建)。
  */
-export declare const MIGRATION_APPLIED_AS: readonly ["moved", "rewritten", "dropped-shadowed", "dropped-inert", "refused"];
+export declare const MIGRATION_APPLIED_AS: readonly ["moved", "rewritten", "dropped-shadowed", "dropped-inert", "refused", "minted"];
 export type MigrationAppliedAs = (typeof MIGRATION_APPLIED_AS)[number];
-/** 收据指向的那份文档:配置域名、retired 域名(`runtime`)、`config.d/remote-exec.json`(`remote-exec`),或调度店(`scheduler-store`)。 */
-export type MigrationDocument = DomainName | RetiredDomainName | typeof REMOTE_EXEC_DOCUMENT | "scheduler-store";
+/** 收据指向的那份文档:配置域名、retired 域名(`runtime`)、`config.d/remote-exec.json`(`remote-exec`)、调度店(`scheduler-store`),
+ *  或配置根上的 env 模型表决定(`config.env-models`,SS-M11 铸)。 */
+export type MigrationDocument = DomainName | RetiredDomainName | typeof REMOTE_EXEC_DOCUMENT | "scheduler-store" | typeof ENV_MODELS_DOCUMENT;
 /** 文档里的段坐标(字符串段 = 对象键,数字段 = 数组下标;与告警坐标同一形)。 */
 export type MigrationPath = readonly (string | number)[];
 interface ReceiptBase {
@@ -35,7 +39,7 @@ export type MigrationReceipt = (ReceiptBase & {
         readonly path: MigrationPath;
     };
 }) | (ReceiptBase & {
-    readonly appliedAs: "rewritten" | "dropped-shadowed" | "dropped-inert";
+    readonly appliedAs: "rewritten" | "dropped-shadowed" | "dropped-inert" | "minted";
 }) | (ReceiptBase & {
     readonly appliedAs: "refused";
     readonly reason: string;

package/dist/migration-receipt.js

@@ -1,12 +1,14 @@
 /** 本版登记的一次性**数据**迁移 id(闭集;每个 id 在 `ONE_TIME_MIGRATIONS` 登记表里恰一行)。收据只许这些 id —— 同表登记的 wire 删码位
  *  (`WIRE_RETIREMENT_IDS`,`./one-time-migrations`)不改任何存储形,铸不出收据,不在本集。 */
-export const ONE_TIME_MIGRATION_IDS = ["SS-M1", "SS-M2", "SS-M3", "SS-M4", "SS-M5", "SS-M6", "SS-M7", "SS-M8", "SS-M9", "SS-M10"];
+export const ONE_TIME_MIGRATION_IDS = ["SS-M1", "SS-M2", "SS-M3", "SS-M4", "SS-M5", "SS-M6", "SS-M7", "SS-M8", "SS-M9", "SS-M10", "SS-M11"];
 /**
  * 一条收据说迁移**对一个坐标做了什么**(闭集,每词一义):
  *  - `moved`            — 值搬到新位(`to`),义不变;
  *  - `rewritten`        — 同一坐标上的值换成今天的生效读法(例:URL 剥掉从不上线的 fragment、调度行的 durable 键重铸、6.x 的 worker 行换新形);
  *  - `dropped-shadowed` — 删掉;它从来没生效过,因为另一个位赢了(例:`governance` 已设时 `runtime` 上的治理旧键、`sealedApiKey` 在场时的 `apiKeyEnv`);
  *  - `dropped-inert`    — 删掉;今天的读法本就不让它生效(例:超界的主机条目、引擎从不读的旧字段、空的retired 域文档);
- *  - `refused`          — 不改:要改就得替运维猜(或旧文档今天本就读不进);原样留着,读侧照旧响亮拒,`reason` 说为什么。
+ *  - `refused`          — 不改:要改就得替运维猜(或旧文档今天本就读不进);原样留着,读侧照旧响亮拒,`reason` 说为什么;
+ *  - `minted`           — 在**缺席处**写下一份新事实(一份部署决定),不改任何已有的值 —— 只有 SS-M11 铸(配置根的 `config.env-models.json`:
+ *                         升级前「管模型面的目录整表顶替 env 模型」的读法,写成 `replaced`;不存在才建)。
  */
-export const MIGRATION_APPLIED_AS = ["moved", "rewritten", "dropped-shadowed", "dropped-inert", "refused"];
+export const MIGRATION_APPLIED_AS = ["moved", "rewritten", "dropped-shadowed", "dropped-inert", "refused", "minted"];

package/dist/node.d.ts

@@ -12,3 +12,4 @@ export * from "./scheduler-store-node.js";
 export { migrateConfigDirectory, migrateConfigDocuments, // 14.5.0:同一段「迁 → 整域终判」的同步口(入参是已有的存量文档,无 io)—— 目录形调的就是它的内核
 type ConfigDirectoryDocument, type ConfigDirectoryIo, type ConfigDirectoryMigration, type ConfigDirectoryRefusal, type ConfigDocumentsMigration, type MigrateConfigDirectoryOptions, type MigrateConfigDocumentsOptions, } from "./config-dir-migration.js";
 export { nodeConfigDirectoryIo } from "./config-dir-io.js";
+export { migrateEnvModelsDecision, nodeConfigRootIo, readEnvModelsDecision, readMigrationMarker, writeEnvModelsDecision, type ConfigRootIo, type EnvModelsDecisionWrite, type EnvModelsMigration, type EnvModelsMint, } from "./config-root-node.js";

package/dist/node.js

@@ -13,3 +13,5 @@ export * from "./scheduler-store-node.js"; // R7 self-wake scheduler store — f
 export { migrateConfigDirectory, migrateConfigDocuments, // 14.5.0:同一段「迁 → 整域终判」的同步口(入参是已有的存量文档,无 io)—— 目录形调的就是它的内核
  } from "./config-dir-migration.js";
 export { nodeConfigDirectoryIo } from "./config-dir-io.js"; // 上面那只函数的真 I/O 绑定:node:fs + 本包唯一的原子写器(config-document 模式规则)
+// 配置根上的决定文档(config.env-models.json)与按 id 的运行记录(config.migration.<id>.json)的两只读者、决定文档的唯一写函数(运行记录由迁移独占创建),与一次性迁移 SS-M11 的迁移体(名字与闭集答案表在包根)。显式列名。
+export { migrateEnvModelsDecision, nodeConfigRootIo, readEnvModelsDecision, readMigrationMarker, writeEnvModelsDecision, } from "./config-root-node.js";