@sema-agent/settings-schema 10.1.1 → 11.1.0

package/dist/center-credential.d.ts

@@ -1,116 +0,0 @@
-/**
- * 中心(config-center 产品)凭证的**文件形契约** —— S-698(design/325 §1)。
- *
- * 引擎向中心出站时用的凭证由部署声明(见 server `src/center-credential.ts`,单属主);声明成文件时
- * (`SEMA_REGISTRY_TOKEN_FILE`),文件内容有两种**种类**,不是一种语义的两种拼法:
- *
- *  · **裸行**(一个静态令牌,种类与今天相同):首行 = 静态 bearer,只收可打印 ASCII({@link TokenString} 的律)。它是用户 JWT 还是 worker
- *    拉取令牌,由读方用 `looksLikeJwt`(`./api/auth-bridge`)自判 —— 本文件不重判种类。
- *  · **信封**(新):一个 JSON 对象,形 = {@link CenterCredentialEnvelope}。今只有一员 `kind:"user-session"`
- *    (人的登录会话:可轮换的访问令牌 + 单次有效的刷新令牌 + 到期时刻 + 签发它的中心根 URL)。worker 拉取
- *    令牌**不进信封**:它不轮换、不属于人,保持裸行。
- *
- * 判别律(一条,{@link parseCenterCredentialFile} 是它的**唯一**实现):内容 `trim()` 后以 `{` 开头 ⇒ 只按
- * 信封读,读不成 = `unreadable`(**不回落**成裸行 —— 一个 `{` 开头的裸 token 不存在,回落只会把一段坏 JSON
- * 当 bearer 发出去);否则裸行;空 = `unreadable`。同一份内容只有一种读法(零双读)。
- *
- * 声明面(S-742,本文件尾段):两个声明键名 {@link CENTER_CREDENTIAL_ENV} 与二选一判官
- * {@link judgeCenterCredentialDeclaration} —— 规则此前只活在 server,管理面 / 壳各自手抄键名。
- *
- * 纯契约:零 IO(读文件、写文件、续签都是消费方的事),browser-safe,与本包其余部分同一条纯度律。
- */
-import { z } from "zod";
-/** 信封 `kind` 的闭集今只有一员(`SEALED_BOX_ALG` 同式的字面常量:schema 的字面与读方的比较都引它)。 */
-export declare const CENTER_CREDENTIAL_ENVELOPE_KIND: "user-session";
-/**
- * 中心凭证**信封**(`SEMA_REGISTRY_TOKEN_FILE` 指向的文件是一个 JSON 对象时的唯一形)。`.strict()`:
- * 多一个键就不是这份契约(拼错的 `refresh_token` 被静默剥掉,续签就会拿着缺席的刷新令牌去撞中心)。
- *
- *  · `accessToken` —— 出站 bearer(中心签的用户 JWT,形判 `looksLikeJwt`);读方拿它做身份分箱的方式与裸行
- *    `user-jwt` 逐字同。令牌形与裸行同一条律({@link TokenString})。
- *  · `refreshToken` —— 单次有效、严格轮换(`POST /api/v1/auth/token/refresh`,见 `./api/auth`);续签前**重读
- *    文件**取当前值,不用内存旧值(另一个写者可能刚轮换过)。
- *  · `expiresAt` —— 访问令牌到期时刻(RFC 3339)。
- *  · `issuer` —— 签发它的中心的**基础 URL**(与读方 `configCenter.url` 同形,可带路径前缀):续签只向同源的中心发,
- *    同不同源由读方比。URL 形判据与 `remoteExec` 的端点同一只 {@link NON_SECRET_URL}(http(s)、有 host、userinfo 与
- *    query / fragment 里不许夹带凭据)—— 本包不另写一份更窄的 URL 律。
- */
-export declare const CenterCredentialEnvelope: z.ZodObject<{
-    kind: z.ZodLiteral<"user-session">;
-    accessToken: z.ZodEffects<z.ZodString, string, string>;
-    refreshToken: z.ZodString;
-    expiresAt: z.ZodString;
-    issuer: z.ZodEffects<z.ZodString, string, string>;
-}, "strict", z.ZodTypeAny, {
-    kind: "user-session";
-    issuer: string;
-    accessToken: string;
-    refreshToken: string;
-    expiresAt: string;
-}, {
-    kind: "user-session";
-    issuer: string;
-    accessToken: string;
-    refreshToken: string;
-    expiresAt: string;
-}>;
-export type CenterCredentialEnvelope = z.infer<typeof CenterCredentialEnvelope>;
-/** {@link parseCenterCredentialFile} 的三态结果(判别键 `kind`)。`unreadable.reason` 只说**哪里**不对
- *  (信封字段名 / zod 问题码 / 未知键**个数**),从不回显文件内容 —— 文件里装的就是凭据。 */
-export type CenterCredentialFile = {
-    kind: "bare";
-    bearer: string;
-} | {
-    kind: "envelope";
-    envelope: CenterCredentialEnvelope;
-} | {
-    kind: "unreadable";
-    reason: string;
-};
-/**
- * 凭证文件内容 → 三态({@link CenterCredentialFile})。判别律见模块头注,本函数是它的唯一实现:
- *
- *  1. `trim()`(含 BOM);空 ⇒ `unreadable("empty")`。
- *  2. 以 `{` 开头 ⇒ 只按 {@link CenterCredentialEnvelope} 读:JSON 不成立或 schema 不过 ⇒ `unreadable`
- *     (**不回落**裸行)。
- *  3. 否则 ⇒ 首行(第一个 CR 或 LF 之前,再剥一次空白)。它是令牌({@link TokenString} 的律)⇒ `bare`;
- *     不是 ⇒ `unreadable`(放不进 Authorization 头的行不是 bearer)。多行文件只认首行。
- *
- * 纯函数、零 IO;读方负责读文件(以及文件不可读时自己的那条 `unreadable` 臂)。
- */
-export declare function parseCenterCredentialFile(text: string): CenterCredentialFile;
-/**
- * 中心凭证的两个**声明键名**(部署 env)。一处定义、三方 import(server 读、管理面给 worker 渲染、壳给本机
- * 引擎写)—— 键名是 wire 面,手抄的键名会静默漂。
- *
- *  · `token`(`SEMA_REGISTRY_TOKEN`)—— 值即凭证(部署注入;读方在进程生命期内读一次)。
- *  · `tokenFile`(`SEMA_REGISTRY_TOKEN_FILE`)—— 凭证文件的路径,读方**每次取值都读文件**(轮换 / 换账号只需
- *    改写文件,不重启);文件内容的读法见 {@link parseCenterCredentialFile}。
- */
-export declare const CENTER_CREDENTIAL_ENV: {
-    readonly token: "SEMA_REGISTRY_TOKEN";
-    readonly tokenFile: "SEMA_REGISTRY_TOKEN_FILE";
-};
-/** {@link judgeCenterCredentialDeclaration} 的结果:凭证在哪里声明。`env` 形带**值** —— 它就是凭据,只在读方
- *  自己的凭证模块里流转,不进日志。 */
-export type CenterCredentialDeclaration = {
-    from: "env";
-    token: string;
-} | {
-    from: "file";
-    path: string;
-} | {
-    from: "absent";
-};
-/**
- * 读两个声明键,判凭证在哪里声明 —— 二选一规则的**唯一**实现:
- *
- *  · 空串 = 未设(`undefined` 同);其余一律算「设了」(不 trim —— 与规则上提前 server 的读法逐字同)。
- *  · 两个都设 ⇒ **throw**(读方拒启):两个写者写同一个语义面,哪个赢都是猜。拒句点名两个键、不回显值。
- *  · 只设 `tokenFile` ⇒ `{from:"file", path}`,`path` **原样**:相对路径按 cwd 解析是读方的事(纯契约不碰
- *    `node:path`,也不知道读方的 cwd)。
- *  · 只设 `token` ⇒ `{from:"env", token}`;都不设 ⇒ `{from:"absent"}`。
- *
- * 只读这两个键,别的 env 一概不看。
- */
-export declare function judgeCenterCredentialDeclaration(env: Readonly<Record<string, string | undefined>>): CenterCredentialDeclaration;

package/dist/issue-text.d.ts

@@ -1,10 +0,0 @@
-/**
- * The ONE rendering of a zod issue into a sentence that may leave in a report which promises to name fields, never values (the
- * workers migration's `refused[].reason`, the `migrate-workers` CLI report). Internal — not on any package subpath.
- *
- * zod's own messages name the expected shape, not the input, with one exception: the default `invalid_enum_value` message ends in
- * `, received '<the value>'`. That issue is re-worded from its options alone (the closed set it expected); every other issue keeps
- * its message as is. The result still goes through the usual secret redaction where the caller applies it.
- */
-import type { z } from "zod";
-export declare function issueText(issue: z.ZodIssue): string;

package/dist/issue-text.js

@@ -1,8 +0,0 @@
-export function issueText(issue) {
-    switch (issue.code) {
-        case "invalid_enum_value":
-            return `Invalid enum value. Expected ${issue.options.map((o) => `'${String(o)}'`).join(" | ")}`;
-        default:
-            return issue.message;
-    }
-}

package/dist/migrate-workers.d.ts

@@ -1,71 +0,0 @@
-/**
- * workers 域的**一次性迁移**(7.0.0,M-R2 WorkerSpec 结构块)—— 持久面唯一允许的过渡,窗口关了就整文件删除
- * (连同 `types.ts` 里「删除项读到即拒」那一只预处理)。纯函数、无 I/O、不改入参;文件形的入口是
- * `npx @sema-agent/settings-schema migrate-workers <file>`(`bin/settings-schema.mjs`,同一只函数;命令拼写的唯一正本 = `MIGRATE_WORKERS_COMMAND`)。
- *
- * ## 谁跑、在哪
- * 读前抬升:在 `parseDomain("workers", raw)` / `DOMAIN_SCHEMAS.workers.safeParse` **之前**对**原始 JSON** 跑 —— workers 是
- * 「读即抛」的 gate 域,6.x 存下来的行在 7.0.0 schema 上整域读不出来(删除项响亮拒、enabled 的 worker 缺两块)。中心在它唯一的
- * workers 读口跑一次,结果写回;CLI 给文件后端 / 离线用。
- *
- * ## 规则(每个旧键恰好一种去处)
- *  · **车道**:`env.REMOTE_EXEC` 是车道词 ⇒ `runtime.execution.lane`;同车道的 env 键 ⇒ `coords`,同车道的 `secretEnv` 密钥 ⇒
- *    `secretRefs`(都按导出表 `EXECUTION_LANES` 的栏判)。别车道的键、`REQUIRE_EXECUTION_LANE` ⇒ **dropped**(引擎只读被点名车道
- *    那一臂;声明了车道就恒渲 true)—— 今天就是惰性的。**enabled 且无 `REMOTE_EXEC` ⇒ refused**:那是「无手照回 completed」的
- *    病例本身,迁移不替运维猜车道。停用且无 `REMOTE_EXEC` ⇒ 不写车道,残留车道键 dropped。
- *  · **店**:`sessionBackend` ⇒ `store.session`(`tidb` ⇒ `mysql`,且 `store.backend` 由此为 `mysql`);`memoryBackend` ⇒ **dropped**
- *    (它从未到达引擎);`coords.tidbHost` 在 ⇒ `store.backend = mysql`,`coords.tidb*` + `runtime.db` ⇒ `store.db`(缺端口 ⇒ 引擎
- *    `MYSQL_PORT` 的缺省 3306),`secretRefs.tidbPasswordEnv` ⇒ `secretRefs.dbPasswordEnv`;没有 host ⇒ `store.backend = local`
- *    (设计稿 §3.4:推一次、写死),零散坐标惰性 ⇒ dropped。`env` 逃生口里的 `DB_BACKEND` / `MEMORY_ENGINE` /
- *    `MEMORY_ENGINE_BACKEND`(渲染器以前不渲,运维只能写在那里)⇒ 搬进 `store`,显式的 `DB_BACKEND` 优先。停用且旧形没点名任何店
- *    (无 host、无 `DB_BACKEND`、无 `tidb` 词)⇒ 不写店,旧字段 dropped。
- *  · **表达不了 ⇒ refused**:值写错了栏(密钥以字面值写在 env、坐标来自宿主密钥)、不认识的词、新旧两形并存、`DB_BACKEND=pg`
- *    配 MySQL 族坐标 —— 迁移不搬值进密钥位、不读宿主密钥、不替运维挑赢家、不换库。
- *
- * ## 终判(逐行:迁过的行与没动的行同一只)
- * 每一只**认得出名字**的 worker —— 迁过的、没动的一样 —— 都过读侧自己的判据:**只含这一行的 workers 域**读不读得进
- * (`WorkersConfig`,就是 `parseDomain("workers")` 用的那一只 schema)。读不进 ⇒ refused,拒因是 schema 自己的 issue(例:多租户 + host
- * 车道、点了车道却缺必需坐标、`env` 里设了保留名、`replicas` 与 `autoscaling` 并存)。迁移不复述任何一条写闸规则,也不另抄保留名表:
- * 判据只有读侧那一只。所以 `doc` 里每一只认得出名字的 worker 单独都读得进。
- *
- * 整域读侧仍是**最后围栏**,只剩两类归它:认不出名字的条目(不是对象 / 没有字符串名字 —— 迁移不判形,原样留在 `doc`)与跨行规则
- * (名字 / 路由前缀唯一 —— 两行单独都读得进,合起来才不行,迁移不替运维挑留哪一行)。
- *
- * refused 的 worker **不进**输出 `doc`(中心不加载它、在列表标红点名 `field`;CLI 有 refused 就一字不写),但随 `refused[].original`
- * 逐字带回:`doc` ∪ `refused[].original` 覆盖输入的全部 worker,中心写回前按 `index` 放回(或另存),运维的 spec 不会随迁移消失。
- * 拒因 / dropped 只点名字段,不回显值。
- *
- * ## 幂等
- * 已迁形且逐行读得进(没有任何旧键、该有的块都在)⇒ 原样(同一引用)返回、`changed = []`。所以再跑一次 ⇒ 零变化、`doc` 字节相等。
- */
-import { type ConfigPath } from "./config-fns.js";
-/** 一个被丢掉的旧字段(引擎本就不读它 —— 通知一行,不是错误)。`field` 相对该 worker 条目;`index` = 它在输入 `workers` 里的下标。 */
-export interface WorkersMigrationDrop {
-    readonly name: string;
-    readonly index: number;
-    readonly field: ConfigPath;
-}
-/** 一只迁不了的 worker(不进输出 `doc`)。`field` 指到要人改的那一格(相对该 worker 条目;终判拒时是读侧 schema issue 的路径 ——
- *  迁过的行指迁出形里的格,没动的行指存下来那一行的格),
- *  `reason` 只点名字段、不回显值。`original` = 输入里那一行**逐字**(同一个值,未拷贝未改写)——
- *  🔴 **写回 `doc` 之前必须把每个 `refused[].original` 按 `index` 放回(或另存)**,否则这只 worker 的 spec 随写回从存储里消失,
- *  运维看到的是「worker 不见了」而不是「worker 被标红」。它是调用方自己的数据,原样带回;要记日志,按调用方记那一行的规矩记。 */
-export interface WorkersMigrationRefusal {
-    readonly name: string;
-    readonly index: number;
-    readonly field: ConfigPath;
-    readonly reason: string;
-    readonly original: unknown;
-}
-/** `migrateWorkersDomain` 的结果。`changed` = 被改写的 worker 名(含只丢了旧字段的)。 */
-export interface WorkersDomainMigration {
-    readonly doc: unknown;
-    readonly changed: readonly string[];
-    readonly dropped: readonly WorkersMigrationDrop[];
-    readonly refused: readonly WorkersMigrationRefusal[];
-}
-/**
- * 迁移一份 workers 域**原始**文档(`{ workers: [...] }`)。不是这个形 ⇒ 原样返回(判形是 `parseDomain` 的事,迁移不抛)。
- * 规则、幂等与 refused 的处置见文件头。
- */
-export declare function migrateWorkersDomain(doc: unknown): WorkersDomainMigration;

package/dist/migrate-workers.js

@@ -1,351 +0,0 @@
-/**
- * workers 域的**一次性迁移**(7.0.0,M-R2 WorkerSpec 结构块)—— 持久面唯一允许的过渡,窗口关了就整文件删除
- * (连同 `types.ts` 里「删除项读到即拒」那一只预处理)。纯函数、无 I/O、不改入参;文件形的入口是
- * `npx @sema-agent/settings-schema migrate-workers <file>`(`bin/settings-schema.mjs`,同一只函数;命令拼写的唯一正本 = `MIGRATE_WORKERS_COMMAND`)。
- *
- * ## 谁跑、在哪
- * 读前抬升:在 `parseDomain("workers", raw)` / `DOMAIN_SCHEMAS.workers.safeParse` **之前**对**原始 JSON** 跑 —— workers 是
- * 「读即抛」的 gate 域,6.x 存下来的行在 7.0.0 schema 上整域读不出来(删除项响亮拒、enabled 的 worker 缺两块)。中心在它唯一的
- * workers 读口跑一次,结果写回;CLI 给文件后端 / 离线用。
- *
- * ## 规则(每个旧键恰好一种去处)
- *  · **车道**:`env.REMOTE_EXEC` 是车道词 ⇒ `runtime.execution.lane`;同车道的 env 键 ⇒ `coords`,同车道的 `secretEnv` 密钥 ⇒
- *    `secretRefs`(都按导出表 `EXECUTION_LANES` 的栏判)。别车道的键、`REQUIRE_EXECUTION_LANE` ⇒ **dropped**(引擎只读被点名车道
- *    那一臂;声明了车道就恒渲 true)—— 今天就是惰性的。**enabled 且无 `REMOTE_EXEC` ⇒ refused**:那是「无手照回 completed」的
- *    病例本身,迁移不替运维猜车道。停用且无 `REMOTE_EXEC` ⇒ 不写车道,残留车道键 dropped。
- *  · **店**:`sessionBackend` ⇒ `store.session`(`tidb` ⇒ `mysql`,且 `store.backend` 由此为 `mysql`);`memoryBackend` ⇒ **dropped**
- *    (它从未到达引擎);`coords.tidbHost` 在 ⇒ `store.backend = mysql`,`coords.tidb*` + `runtime.db` ⇒ `store.db`(缺端口 ⇒ 引擎
- *    `MYSQL_PORT` 的缺省 3306),`secretRefs.tidbPasswordEnv` ⇒ `secretRefs.dbPasswordEnv`;没有 host ⇒ `store.backend = local`
- *    (设计稿 §3.4:推一次、写死),零散坐标惰性 ⇒ dropped。`env` 逃生口里的 `DB_BACKEND` / `MEMORY_ENGINE` /
- *    `MEMORY_ENGINE_BACKEND`(渲染器以前不渲,运维只能写在那里)⇒ 搬进 `store`,显式的 `DB_BACKEND` 优先。停用且旧形没点名任何店
- *    (无 host、无 `DB_BACKEND`、无 `tidb` 词)⇒ 不写店,旧字段 dropped。
- *  · **表达不了 ⇒ refused**:值写错了栏(密钥以字面值写在 env、坐标来自宿主密钥)、不认识的词、新旧两形并存、`DB_BACKEND=pg`
- *    配 MySQL 族坐标 —— 迁移不搬值进密钥位、不读宿主密钥、不替运维挑赢家、不换库。
- *
- * ## 终判(逐行:迁过的行与没动的行同一只)
- * 每一只**认得出名字**的 worker —— 迁过的、没动的一样 —— 都过读侧自己的判据:**只含这一行的 workers 域**读不读得进
- * (`WorkersConfig`,就是 `parseDomain("workers")` 用的那一只 schema)。读不进 ⇒ refused,拒因是 schema 自己的 issue(例:多租户 + host
- * 车道、点了车道却缺必需坐标、`env` 里设了保留名、`replicas` 与 `autoscaling` 并存)。迁移不复述任何一条写闸规则,也不另抄保留名表:
- * 判据只有读侧那一只。所以 `doc` 里每一只认得出名字的 worker 单独都读得进。
- *
- * 整域读侧仍是**最后围栏**,只剩两类归它:认不出名字的条目(不是对象 / 没有字符串名字 —— 迁移不判形,原样留在 `doc`)与跨行规则
- * (名字 / 路由前缀唯一 —— 两行单独都读得进,合起来才不行,迁移不替运维挑留哪一行)。
- *
- * refused 的 worker **不进**输出 `doc`(中心不加载它、在列表标红点名 `field`;CLI 有 refused 就一字不写),但随 `refused[].original`
- * 逐字带回:`doc` ∪ `refused[].original` 覆盖输入的全部 worker,中心写回前按 `index` 放回(或另存),运维的 spec 不会随迁移消失。
- * 拒因 / dropped 只点名字段,不回显值。
- *
- * ## 幂等
- * 已迁形且逐行读得进(没有任何旧键、该有的块都在)⇒ 原样(同一引用)返回、`changed = []`。所以再跑一次 ⇒ 零变化、`doc` 字节相等。
- */
-import { formatConfigPath, redactSecrets } from "./config-fns.js";
-import { LANE_ENV_OWNER, STORE_ENV_KEYS, isLaneEnvKey } from "./execution-lane-index.js";
-import { EXECUTION_LANE_WORDS, MEMORY_ENGINE_BACKENDS, STORE_BACKENDS } from "./execution-lanes.js";
-import { issueText } from "./issue-text.js";
-import { WorkersConfig } from "./types.js";
-function isRec(v) {
-    return v !== null && typeof v === "object" && !Array.isArray(v);
-}
-/** 6.x 删除项:`[容器, 键]`。 */
-const SIX_X_STORE_FIELDS = [
-    ["runtime", "sessionBackend"],
-    ["runtime", "memoryBackend"],
-    ["runtime", "db"],
-    ["coords", "tidbHost"],
-    ["coords", "tidbPort"],
-    ["coords", "tidbUser"],
-    ["secretRefs", "tidbPasswordEnv"],
-];
-/** 引擎 `MEMORY_ENGINE` 的两族词(server `src/config.ts` :3011–3012,比较前 trim + 小写)。 */
-const MEMORY_ENGINE_ON_WORDS = ["on", "true", "1", "yes", "enabled"];
-const MEMORY_ENGINE_OFF_WORDS = ["off", "false", "0", "no", "disabled"];
-/** 引擎 `MYSQL_PORT` 的缺省(server `src/config.ts` :1818)—— 旧形没写端口时引擎连的就是它。 */
-const MYSQL_DEFAULT_PORT = 3306;
-function isLaneWord(v) {
-    return typeof v === "string" && EXECUTION_LANE_WORDS.some((w) => w === v);
-}
-function isStoreWord(v) {
-    return typeof v === "string" && STORE_BACKENDS.some((w) => w === v);
-}
-function isMemoryBackendWord(v) {
-    return typeof v === "string" && MEMORY_ENGINE_BACKENDS.some((w) => w === v);
-}
-/** 拒因里只点名形如词的值(短、小写);其余一律不回显(值可能是粘错位置的凭据)。 */
-function describeWord(v) {
-    return typeof v === "string" && /^[a-z0-9][a-z0-9-]{0,31}$/.test(v) ? `"${v}"` : "(value not shown)";
-}
-const UNCHANGED = { kind: "unchanged" };
-function migrateEntry(raw, index) {
-    if (!isRec(raw) || typeof raw.name !== "string")
-        return UNCHANGED; // 不是一只可辨认的 worker:判形是 parseDomain 的事
-    const name = raw.name;
-    const refuse = (field, reason) => ({ kind: "refused", refusal: { name, index, field, reason: redactSecrets(reason), original: raw } });
-    const enabled = raw.enabled !== false;
-    const has = (container, key) => isRec(container) && Object.hasOwn(container, key);
-    const laneKeysOf = (rec) => (isRec(rec) ? Object.keys(rec).filter(isLaneEnvKey) : []);
-    const storeKeysOf = (rec) => (isRec(rec) ? STORE_ENV_KEYS.filter((k) => Object.hasOwn(rec, k)) : []);
-    const envLaneKeys = laneKeysOf(raw.env);
-    const secretLaneKeys = laneKeysOf(raw.secretEnv);
-    const envStoreKeys = storeKeysOf(raw.env);
-    const secretStoreKeys = storeKeysOf(raw.secretEnv);
-    const oldStoreFields = SIX_X_STORE_FIELDS.filter(([c, k]) => has(raw[c], k));
-    const hasExecution = has(raw.runtime, "execution");
-    const hasStore = has(raw.runtime, "store");
-    const laneTouched = envLaneKeys.length + secretLaneKeys.length > 0;
-    const storeTouched = oldStoreFields.length + envStoreKeys.length + secretStoreKeys.length > 0;
-    if (hasExecution && laneTouched) {
-        return refuse(["runtime", "execution"], `declares runtime.execution AND execution-lane keys in env / secretEnv (${[...envLaneKeys, ...secretLaneKeys].join(", ")}) — keep one form; the migration does not pick a winner`);
-    }
-    // 新形的店字段有两处:`runtime.store` 与 `secretRefs.dbPasswordEnv`(gpt-6 腿 F1:只看前者时,手填过新口令引用、又留着旧
-    // `tidbPasswordEnv` 的行会被旧引用静默覆盖)。任一在场 ∧ 还有旧店字段 ⇒ 两形并存,不挑赢家。
-    const newStoreFields = [...(hasStore ? ["runtime.store"] : []), ...(has(raw.secretRefs, "dbPasswordEnv") ? ["secretRefs.dbPasswordEnv"] : [])];
-    if (newStoreFields.length > 0 && storeTouched) {
-        const old = [...oldStoreFields.map(([c, k]) => `${c}.${k}`), ...envStoreKeys.map((k) => `env.${k}`), ...secretStoreKeys.map((k) => `secretEnv.${k}`)];
-        return refuse(["runtime", "store"], `declares the 7.0.0 store fields (${newStoreFields.join(", ")}) AND 6.x store fields (${old.join(", ")}) — keep one form; the migration does not pick a winner`);
-    }
-    const secretStoreKey = secretStoreKeys[0];
-    if (secretStoreKey !== undefined)
-        return refuse(["secretEnv", secretStoreKey], `${secretStoreKey} is set from a host secret — the migration cannot read it; declare runtime.store by hand`);
-    if (has(raw.secretEnv, "REMOTE_EXEC"))
-        return refuse(["secretEnv", "REMOTE_EXEC"], "the execution lane is set from a host secret — the migration cannot read it; declare runtime.execution.lane by hand");
-    const needLane = !hasExecution && (enabled || laneTouched);
-    const needStore = !hasStore && (enabled || storeTouched);
-    if (!needLane && !needStore) {
-        const refusal = rowVerdict(raw, "stored");
-        return refusal === undefined ? UNCHANGED : refuse(refusal.field, refusal.reason);
-    }
-    const w = structuredClone(raw);
-    const runtime = isRec(w.runtime) ? w.runtime : {};
-    w.runtime = runtime;
-    const env = isRec(w.env) ? w.env : {};
-    const secretEnv = isRec(w.secretEnv) ? w.secretEnv : {};
-    const coords = isRec(w.coords) ? w.coords : {};
-    const secretRefs = isRec(w.secretRefs) ? w.secretRefs : {};
-    const dropped = [];
-    const drop = (container, slot, key) => {
-        delete container[key];
-        dropped.push({ name, index, field: [slot, key] });
-    };
-    // ── 车道 ─────────────────────────────────────────────────────────────────────────────────────────
-    if (needLane) {
-        const rx = env.REMOTE_EXEC;
-        if (rx === undefined || rx === "") {
-            if (enabled) {
-                return refuse(["env", "REMOTE_EXEC"], `an enabled worker names no execution lane (env.REMOTE_EXEC is unset) — it boots with no hands and still reports tasks completed. ` +
-                    `The migration does not guess a lane: set runtime.execution.lane (${EXECUTION_LANE_WORDS.join(" | ")}) by hand, or disable the worker`);
-            }
-            for (const k of envLaneKeys)
-                drop(env, "env", k); // 停用且没点名车道 ⇒ 每个车道键都是惰性的
-            for (const k of secretLaneKeys)
-                drop(secretEnv, "secretEnv", k);
-        }
-        else {
-            if (!isLaneWord(rx)) {
-                return refuse(["env", "REMOTE_EXEC"], `env.REMOTE_EXEC ${describeWord(rx)} is not an execution lane (${EXECUTION_LANE_WORDS.join(" | ")}) — the engine refuses to start with it; set runtime.execution.lane by hand`);
-            }
-            const lane = rx;
-            const laneCoords = {};
-            const laneSecretRefs = {};
-            for (const k of envLaneKeys) {
-                if (k === "REMOTE_EXEC") {
-                    delete env[k];
-                    continue;
-                }
-                const owner = LANE_ENV_OWNER.get(k);
-                if (owner === undefined || owner.lane !== lane) {
-                    drop(env, "env", k); // REQUIRE_EXECUTION_LANE(声明了车道就恒渲 true)与别车道的键(引擎只读被点名那一臂)
-                    continue;
-                }
-                const v = env[k];
-                if (owner.secret) {
-                    return refuse(["env", k], `${k} is a secret of lane "${lane}" but env carries it as a literal value — the migration does not move a value into a secret slot: put it in the host secret source and reference it from runtime.execution.secretRefs.${k}`);
-                }
-                if (typeof v !== "string")
-                    return refuse(["env", k], `env.${k} is not a string`);
-                laneCoords[k] = v;
-                delete env[k];
-            }
-            for (const k of secretLaneKeys) {
-                const owner = LANE_ENV_OWNER.get(k);
-                if (owner === undefined || owner.lane !== lane) {
-                    drop(secretEnv, "secretEnv", k);
-                    continue;
-                }
-                const v = secretEnv[k];
-                if (!owner.secret) {
-                    return refuse(["secretEnv", k], `${k} is a non-secret coordinate of lane "${lane}" but is set from a host secret — the migration cannot read the value; write it in runtime.execution.coords.${k} by hand`);
-                }
-                if (typeof v !== "string")
-                    return refuse(["secretEnv", k], `secretEnv.${k} is not a string`);
-                laneSecretRefs[k] = v;
-                delete secretEnv[k];
-            }
-            runtime.execution = { lane, coords: laneCoords, secretRefs: laneSecretRefs };
-        }
-    }
-    // ── 店 ───────────────────────────────────────────────────────────────────────────────────────────
-    if (needStore) {
-        if (Object.hasOwn(runtime, "memoryBackend"))
-            drop(runtime, "runtime", "memoryBackend"); // 从未到达引擎
-        const sessionRaw = runtime.sessionBackend;
-        const host = coords.tidbHost;
-        const hostSet = typeof host === "string" && host !== "";
-        const dbBackendRaw = env.DB_BACKEND;
-        const dbBackendSet = dbBackendRaw !== undefined && dbBackendRaw !== "";
-        const named = hostSet || dbBackendSet || sessionRaw === "tidb";
-        const sqlCoordFields = [
-            [runtime, "runtime", "db"],
-            [coords, "coords", "tidbHost"],
-            [coords, "coords", "tidbPort"],
-            [coords, "coords", "tidbUser"],
-            [secretRefs, "secretRefs", "tidbPasswordEnv"],
-        ];
-        if (!enabled && !named) {
-            // 停用、旧形没点名任何店 ⇒ 不替它发明一个;旧字段全是惰性的
-            if (Object.hasOwn(runtime, "sessionBackend"))
-                drop(runtime, "runtime", "sessionBackend");
-            for (const [c, slot, k] of sqlCoordFields)
-                if (Object.hasOwn(c, k))
-                    drop(c, slot, k);
-            for (const k of STORE_ENV_KEYS)
-                if (Object.hasOwn(env, k))
-                    drop(env, "env", k);
-        }
-        else {
-            let session;
-            if (sessionRaw === undefined)
-                session = "auto"; // 6.x 的缺省
-            else if (sessionRaw === "tidb")
-                session = "mysql";
-            else if (sessionRaw === "memory" || sessionRaw === "auto")
-                session = sessionRaw;
-            else
-                return refuse(["runtime", "sessionBackend"], `runtime.sessionBackend ${describeWord(sessionRaw)} is not a 6.x session backend (tidb | memory | auto)`);
-            delete runtime.sessionBackend;
-            let backend;
-            if (dbBackendSet) {
-                if (!isStoreWord(dbBackendRaw))
-                    return refuse(["env", "DB_BACKEND"], `env.DB_BACKEND ${describeWord(dbBackendRaw)} is not a store backend (${STORE_BACKENDS.join(" | ")}) — the engine refuses to start with it`);
-                backend = dbBackendRaw;
-            }
-            else {
-                backend = hostSet || sessionRaw === "tidb" ? "mysql" : "local";
-            }
-            delete env.DB_BACKEND;
-            const sqlCoordsPresent = sqlCoordFields.filter(([c, , k]) => Object.hasOwn(c, k));
-            const store = { backend, session };
-            if (backend === "mysql") {
-                if (hostSet) {
-                    const port = coords.tidbPort;
-                    store.db = {
-                        host,
-                        port: port === undefined ? MYSQL_DEFAULT_PORT : port,
-                        ...(Object.hasOwn(coords, "tidbUser") ? { user: coords.tidbUser } : {}),
-                        ...(Object.hasOwn(runtime, "db") ? { database: runtime.db } : {}),
-                    };
-                }
-                if (Object.hasOwn(secretRefs, "tidbPasswordEnv"))
-                    secretRefs.dbPasswordEnv = secretRefs.tidbPasswordEnv;
-                for (const [c, , k] of sqlCoordsPresent)
-                    delete c[k];
-            }
-            else if (backend === "pg") {
-                if (sqlCoordsPresent.length > 0) {
-                    return refuse(["env", "DB_BACKEND"], `env.DB_BACKEND=pg but the SQL coordinates are the MySQL family (coords.tidb* / runtime.db / secretRefs.tidbPasswordEnv, rendered as MYSQL_*) — the migration does not move a MySQL server's coordinates onto pg; declare runtime.store by hand`);
-                }
-            }
-            else {
-                for (const [c, slot, k] of sqlCoordsPresent)
-                    drop(c, slot, k); // 非 SQL 店:SQL 坐标在引擎里是「声明不用」的惰性件
-            }
-            const memory = {};
-            const engineRaw = env.MEMORY_ENGINE;
-            if (engineRaw !== undefined) {
-                const word = typeof engineRaw === "string" ? engineRaw.trim().toLowerCase() : undefined;
-                if (word !== undefined && MEMORY_ENGINE_ON_WORDS.includes(word))
-                    memory.engine = "on";
-                else if (word !== undefined && MEMORY_ENGINE_OFF_WORDS.includes(word))
-                    memory.engine = "off";
-                else if (word !== "")
-                    return refuse(["env", "MEMORY_ENGINE"], "env.MEMORY_ENGINE is not an on/off word — the engine refuses to start with it");
-                delete env.MEMORY_ENGINE;
-            }
-            const memoryBackendRaw = env.MEMORY_ENGINE_BACKEND;
-            if (memoryBackendRaw !== undefined) {
-                if (!isMemoryBackendWord(memoryBackendRaw)) {
-                    return refuse(["env", "MEMORY_ENGINE_BACKEND"], `env.MEMORY_ENGINE_BACKEND ${describeWord(memoryBackendRaw)} is not a memory backend (${MEMORY_ENGINE_BACKENDS.join(" | ")}) — the engine refuses to start with it`);
-                }
-                memory.backend = memoryBackendRaw;
-                delete env.MEMORY_ENGINE_BACKEND;
-            }
-            if (Object.keys(memory).length > 0)
-                store.memory = memory;
-            runtime.store = store;
-        }
-    }
-    // 被搬空的 env / secretEnv 整键去掉(它们是可选字段;留一个 `{}` 只是噪声)
-    if (isRec(w.env) && Object.keys(env).length === 0 && isRec(raw.env) && Object.keys(raw.env).length > 0)
-        delete w.env;
-    if (isRec(w.secretEnv) && Object.keys(secretEnv).length === 0 && isRec(raw.secretEnv) && Object.keys(raw.secretEnv).length > 0)
-        delete w.secretEnv;
-    const refusal = rowVerdict(w, "migrated");
-    if (refusal !== undefined)
-        return refuse(refusal.field, refusal.reason);
-    return { kind: "migrated", entry: w, dropped };
-}
-/**
- * 逐行**终判** —— 迁过的行与没动的行同一只(见文件头「终判」):只含这一行的 workers 域读不读得进,判据就是读侧的 `WorkersConfig`
- * (逐行的规则无论写在 `WorkerSpec` 里还是写在域层,都在;跨行规则一行时不触发)。读得进 ⇒ `undefined`;读不进 ⇒ 第一条 issue 的
- * 路径(相对该行)+ 至多三条 issue 的句子(经 `issueText`:不回显输入值)。`stage` 只决定拒因说的是哪一份形(迁出形 / 存储形)。
- */
-function rowVerdict(row, stage) {
-    const verdict = WorkersConfig.safeParse({ workers: [row] });
-    if (verdict.success)
-        return undefined;
-    const issues = verdict.error.issues;
-    const shown = issues.slice(0, 3).map((i) => `${formatConfigPath(rowRelative(i.path))}: ${issueText(i)}`);
-    const more = issues.length > shown.length ? ` (+${issues.length - shown.length} more)` : "";
-    const subject = stage === "migrated" ? "after migration the worker" : "the stored worker";
-    const first = issues[0];
-    return { field: first === undefined ? [] : rowRelative(first.path), reason: `${subject} is not a valid WorkerSpec — ${shown.join("; ")}${more}` };
-}
-/** 一只单行域里的 issue 路径 → 相对那一行(去掉 `["workers", 0]` 前缀;不在那一行下的 issue 原样)。 */
-function rowRelative(path) {
-    return path[0] === "workers" && path[1] === 0 ? path.slice(2) : path;
-}
-/**
- * 迁移一份 workers 域**原始**文档(`{ workers: [...] }`)。不是这个形 ⇒ 原样返回(判形是 `parseDomain` 的事,迁移不抛)。
- * 规则、幂等与 refused 的处置见文件头。
- */
-export function migrateWorkersDomain(doc) {
-    if (!isRec(doc) || !Array.isArray(doc.workers))
-        return { doc, changed: [], dropped: [], refused: [] };
-    const workers = doc.workers;
-    const kept = [];
-    const changed = [];
-    const dropped = [];
-    const refused = [];
-    workers.forEach((entry, index) => {
-        const out = migrateEntry(entry, index);
-        switch (out.kind) {
-            case "unchanged":
-                kept.push(entry);
-                break;
-            case "migrated":
-                kept.push(out.entry);
-                changed.push(String(out.entry.name));
-                dropped.push(...out.dropped);
-                break;
-            case "refused":
-                refused.push(out.refusal);
-                break;
-            default: {
-                const unhandled = out;
-                throw new Error(`migrateWorkersDomain: unhandled outcome ${JSON.stringify(unhandled)}`);
-            }
-        }
-    });
-    if (changed.length === 0 && refused.length === 0)
-        return { doc, changed: [], dropped: [], refused: [] };
-    return { doc: { ...doc, workers: kept }, changed, dropped, refused };
-}