@sema-agent/server 7.138.0 → 7.140.0

package/dist/plugins/execution-placement-sql.js

@@ -0,0 +1,223 @@
+import { isExecutionLane } from "../execution-lane-caps.js";
+import { sessionFaceFromRow } from "../session-incarnation.js";
+import { toIso } from "./sql-row-helpers.js";
+import { WRITABLE, assertPlaceableLane, settledMirrorOutcome, settledPlaceOutcome, } from "../execution-placement.js";
+export const SESSION_META_PLACEMENT_COLUMNS = [
+    { name: "execution_role", mysql: "execution_role VARCHAR(16) NULL", pg: `execution_role VARCHAR(16) COLLATE "C"` },
+    { name: "execution_lane", mysql: "execution_lane VARCHAR(32) NULL", pg: `execution_lane VARCHAR(32) COLLATE "C"` },
+    { name: "execution_device_id", mysql: "execution_device_id VARCHAR(64) NULL", pg: `execution_device_id VARCHAR(64) COLLATE "C"` },
+    { name: "execution_device_owner_tenant", mysql: "execution_device_owner_tenant VARCHAR(190) NULL", pg: `execution_device_owner_tenant VARCHAR(190) COLLATE "C"` },
+    { name: "execution_device_owner_subject", mysql: "execution_device_owner_subject VARCHAR(190) NULL", pg: `execution_device_owner_subject VARCHAR(190) COLLATE "C"` },
+    { name: "execution_placed_at", mysql: "execution_placed_at DATETIME(3) NULL", pg: "execution_placed_at TIMESTAMPTZ(3)" },
+    { name: "execution_rev", mysql: "execution_rev BIGINT NULL", pg: "execution_rev BIGINT" },
+    { name: "fork_key", mysql: "fork_key VARCHAR(255) NULL", pg: `fork_key VARCHAR(255) COLLATE "C"` },
+];
+export function sessionMetaPlacementColumnsDdl(dialect) {
+    return SESSION_META_PLACEMENT_COLUMNS.map((c) => c[dialect]).join(",\n     ");
+}
+const WRITER = "writer";
+const MIRROR = "mirror";
+const NOT_WRITER = "(execution_role IS NULL OR execution_role <> 'writer')";
+export const MIRROR_ON_COMMIT_SET = "execution_role = 'mirror'";
+export const MIRROR_ON_COMMIT_GUARD = NOT_WRITER;
+export function importedRowCells(forkKey) {
+    return { columns: "fork_key, execution_role", values: [forkKey, MIRROR] };
+}
+export const SESSION_META_PLACEMENT_READ_COLUMNS = "owner, incarnation, placement_kind, execution_role, execution_lane, execution_device_id, execution_device_owner_tenant, execution_device_owner_subject, execution_placed_at, execution_rev";
+function binder(dialect) {
+    const values = [];
+    return {
+        values,
+        p: (v) => {
+            values.push(v);
+            return dialect === "pg" ? `$${values.length}` : "?";
+        },
+    };
+}
+function occupantPredicate(dialect, p, root, occupant) {
+    const nullSafeEq = dialect === "pg" ? "IS NOT DISTINCT FROM" : "<=>";
+    return `session_id = ${p(root)} AND incarnation = ${p(occupant.incarnation)} AND owner ${nullSafeEq} ${p(occupant.owner)} AND placement_kind IS NULL`;
+}
+export function readPlacementRowStatement(dialect, root, opts) {
+    const b = binder(dialect);
+    return { text: `SELECT ${SESSION_META_PLACEMENT_READ_COLUMNS} FROM session_meta WHERE session_id = ${b.p(root)}${opts.lock ? " FOR UPDATE" : ""}`, values: b.values };
+}
+export function placeWriterStatement(dialect, root, occupant, cell, now) {
+    const b = binder(dialect);
+    const set = `execution_role = '${WRITER}', execution_lane = ${b.p(cell.lane)}, execution_device_id = ${b.p(cell.device?.id ?? null)}, ` +
+        `execution_device_owner_tenant = ${b.p(cell.device?.owner.tenant ?? null)}, execution_device_owner_subject = ${b.p(cell.device?.owner.subject ?? null)}, ` +
+        `execution_placed_at = ${b.p(now)}, execution_rev = 0`;
+    return { text: `UPDATE session_meta SET ${set} WHERE ${occupantPredicate(dialect, b.p, root, occupant)} AND execution_role IS NULL`, values: b.values };
+}
+export function bindDeviceStatement(dialect, root, occupant, device, now) {
+    const b = binder(dialect);
+    const set = `execution_device_id = ${b.p(device.id)}, execution_device_owner_tenant = ${b.p(device.owner.tenant)}, execution_device_owner_subject = ${b.p(device.owner.subject)}, execution_placed_at = ${b.p(now)}, execution_rev = 0`;
+    return {
+        text: `UPDATE session_meta SET ${set} WHERE ${occupantPredicate(dialect, b.p, root, occupant)} AND execution_role = '${WRITER}' AND execution_lane = 'device' AND execution_device_id IS NULL`,
+        values: b.values,
+    };
+}
+export function rebindDeviceStatement(dialect, root, occupant, owner, expectedRev, targetDeviceId, now) {
+    const b = binder(dialect);
+    const set = `execution_device_id = ${b.p(targetDeviceId)}, execution_placed_at = ${b.p(now)}, execution_rev = execution_rev + 1`;
+    const where = `${occupantPredicate(dialect, b.p, root, occupant)} AND execution_role = '${WRITER}' AND execution_lane = 'device' ` +
+        `AND execution_device_owner_tenant = ${b.p(owner.tenant)} AND execution_device_owner_subject = ${b.p(owner.subject)} AND execution_rev = ${b.p(expectedRev)}`;
+    return { text: `UPDATE session_meta SET ${set} WHERE ${where}`, values: b.values };
+}
+export function markMirrorStatement(dialect, root, occupant) {
+    const b = binder(dialect);
+    return { text: `UPDATE session_meta SET execution_role = '${MIRROR}' WHERE ${occupantPredicate(dialect, b.p, root, occupant)} AND ${NOT_WRITER}`, values: b.values };
+}
+export function backfillWriterStatement(dialect, lane, now) {
+    const b = binder(dialect);
+    return {
+        text: `UPDATE session_meta SET execution_role = '${WRITER}', execution_lane = ${b.p(lane)}, execution_placed_at = ${b.p(now)}, execution_rev = 0 ` +
+            "WHERE execution_role IS NULL AND placement_kind IS NULL AND EXISTS (SELECT 1 FROM task_run tr WHERE tr.session_id = session_meta.session_id)",
+        values: b.values,
+    };
+}
+export function migrateDeviceBindingsStatement(dialect, sourceTable) {
+    if (dialect === "pg") {
+        return {
+            text: `UPDATE session_meta SET execution_role = '${WRITER}', execution_lane = 'device', execution_device_id = ds.device_id, ` +
+                "execution_device_owner_tenant = ds.owner_tenant, execution_device_owner_subject = ds.owner_subject, execution_placed_at = ds.bound_at, execution_rev = ds.rev " +
+                `FROM ${sourceTable} ds WHERE ds.root_session_id = session_meta.session_id AND session_meta.placement_kind IS NULL`,
+            values: [],
+        };
+    }
+    const str = (col) => `CONVERT(ds.${col} USING utf8mb4)`;
+    return {
+        text: `UPDATE session_meta sm JOIN ${sourceTable} ds ON ${str("root_session_id")} COLLATE utf8mb4_bin = sm.session_id ` +
+            `SET sm.execution_role = '${WRITER}', sm.execution_lane = 'device', sm.execution_device_id = ${str("device_id")}, ` +
+            `sm.execution_device_owner_tenant = ${str("owner_tenant")}, sm.execution_device_owner_subject = ${str("owner_subject")}, sm.execution_placed_at = ds.bound_at, sm.execution_rev = ds.rev ` +
+            "WHERE sm.placement_kind IS NULL",
+        values: [],
+    };
+}
+export function countOrphanBindingsStatement(dialect, sourceTable) {
+    const rootKey = dialect === "pg" ? "ds.root_session_id" : "CONVERT(ds.root_session_id USING utf8mb4) COLLATE utf8mb4_bin";
+    return {
+        text: `SELECT COUNT(*) AS orphans FROM ${sourceTable} ds WHERE NOT EXISTS (SELECT 1 FROM session_meta sm WHERE sm.session_id = ${rootKey} AND sm.placement_kind IS NULL)`,
+        values: [],
+    };
+}
+export class ExecutionPlacementRowError extends Error {
+    sessionId;
+    code = "execution_placement.row_unreadable";
+    constructor(sessionId, detail) {
+        super(`session ${sessionId}: the execution placement columns do not form a placement (${detail}) — refusing to read it as any placement`);
+        this.sessionId = sessionId;
+        this.name = "ExecutionPlacementRowError";
+    }
+}
+const isNull = (v) => v === null || v === undefined;
+const text = (v) => (Buffer.isBuffer(v) ? v.toString("utf8") : String(v));
+export function placementCellFromRow(root, row) {
+    const role = row.execution_role;
+    const deviceCols = [row.execution_device_id, row.execution_device_owner_tenant, row.execution_device_owner_subject];
+    if (isNull(role) || role === MIRROR) {
+        if (!isNull(row.execution_lane) || deviceCols.some((v) => !isNull(v)))
+            throw new ExecutionPlacementRowError(root, `role ${isNull(role) ? "NULL" : MIRROR} with a lane or device`);
+        return isNull(role) ? { role: "absent" } : { role: "mirror" };
+    }
+    if (role !== WRITER)
+        throw new ExecutionPlacementRowError(root, `role ${JSON.stringify(text(role))} is not writer / mirror / NULL`);
+    const lane = isNull(row.execution_lane) ? "" : text(row.execution_lane);
+    if (!isExecutionLane(lane))
+        throw new ExecutionPlacementRowError(root, `writer lane ${JSON.stringify(lane)} is not an execution lane`);
+    if (isNull(row.execution_device_id)) {
+        if (deviceCols.some((v) => !isNull(v)))
+            throw new ExecutionPlacementRowError(root, "device owner without a device");
+        return { role: "writer", lane };
+    }
+    if (lane !== "device")
+        throw new ExecutionPlacementRowError(root, `a device on the ${lane} lane`);
+    if (deviceCols.some(isNull) || isNull(row.execution_rev) || isNull(row.execution_placed_at))
+        throw new ExecutionPlacementRowError(root, "a device without its owner, rev or placement time");
+    return {
+        role: "writer",
+        lane,
+        device: {
+            id: text(row.execution_device_id),
+            owner: { tenant: text(row.execution_device_owner_tenant), subject: text(row.execution_device_owner_subject) },
+            rev: Number(row.execution_rev),
+            placedAt: toIso(row.execution_placed_at),
+        },
+    };
+}
+export function placementReadingFromRow(root, row) {
+    if (row === undefined || !isNull(row.placement_kind))
+        return undefined;
+    return { occupant: sessionFaceFromRow(root, isNull(row.owner) ? null : text(row.owner), row.incarnation), cell: placementCellFromRow(root, row) };
+}
+export function rowsOnSqlExec(exec) {
+    return async (sql, values) => (await exec.query(sql, [...values])).rows;
+}
+export async function lockRootAndReadClaim(conn, dialect, root) {
+    const ph = dialect === "pg" ? "$1" : "?";
+    const row = await conn(`SELECT session_id FROM session_meta WHERE session_id = ${ph} FOR UPDATE`, [root]);
+    if (row.length === 0)
+        return { rowPresent: false, activeTaskId: null };
+    const claim = await conn(`SELECT task_id FROM task_active WHERE session_id = ${ph} FOR UPDATE`, [root]);
+    return { rowPresent: true, activeTaskId: claim[0] === undefined ? null : text(claim[0].task_id) };
+}
+export async function readPlacementOn(conn, dialect, root) {
+    const s = readPlacementRowStatement(dialect, root, { lock: true });
+    return placementReadingFromRow(root, (await conn(s.text, s.values))[0]);
+}
+function placementInvariant(root, what) {
+    return new Error(`execution placement of session ${root}: ${what} matched no row while a re-read finds the cell writable — engine/driver anomaly, refusing to guess`);
+}
+export function createSqlExecutionPlacementSeat(db) {
+    const read = async (root) => {
+        const s = readPlacementRowStatement(db.dialect, root, { lock: false });
+        return placementReadingFromRow(root, (await db.query(s.text, [...s.values])).rows[0]);
+    };
+    return {
+        read,
+        async place(root, occupant, cell) {
+            assertPlaceableLane(root, cell);
+            const s = placeWriterStatement(db.dialect, root, occupant, { lane: cell.lane }, new Date());
+            if ((await db.query(s.text, [...s.values])).affected === 1)
+                return { outcome: "placed" };
+            const settled = settledPlaceOutcome(root, await read(root), occupant, cell);
+            if (settled === WRITABLE)
+                throw placementInvariant(root, "place");
+            return settled;
+        },
+        async markMirror(root, occupant) {
+            const conn = await db.connect();
+            try {
+                await conn.begin();
+                const rowsOn = rowsOnSqlExec(conn);
+                const claim = await lockRootAndReadClaim(rowsOn, db.dialect, root);
+                if (!claim.rowPresent) {
+                    await conn.rollback();
+                    return { outcome: "gone" };
+                }
+                const settled = settledMirrorOutcome(root, await readPlacementOn(rowsOn, db.dialect, root), occupant);
+                if (settled !== WRITABLE) {
+                    await conn.rollback();
+                    return settled;
+                }
+                if (claim.activeTaskId !== null) {
+                    await conn.rollback();
+                    return { outcome: "active", activeTaskId: claim.activeTaskId };
+                }
+                const s = markMirrorStatement(db.dialect, root, occupant);
+                if ((await conn.query(s.text, [...s.values])).affected !== 1)
+                    throw placementInvariant(root, "markMirror under a held row lock");
+                await conn.commit();
+                return { outcome: "mirrored" };
+            }
+            catch (err) {
+                await conn.rollback().catch(() => undefined);
+                throw err;
+            }
+            finally {
+                conn.release();
+            }
+        },
+    };
+}
+//# sourceMappingURL=execution-placement-sql.js.map

package/dist/plugins/file-history-store-sql.d.ts

@@ -3,7 +3,7 @@ import type { Pool as PgPool } from "pg";
 import { type FileHistoryRetentionPolicy, type ExecutionEnv, type FileHistoryStore, type FileHistoryResult, type FileHistoryTrackResult, type FileHistoryRestoreResult, type FileHistoryExport, type FileHistoryExportResult } from "@sema-agent/core";
 import { type BlobBackend } from "./blob-backend.js";
 import type { SyncBlobPutResult } from "./store-backend.js";
-import { type SqlDriver } from "./sql-driver.js";
+import { type SqlDriver, type SqlDialect } from "./sql-driver.js";
 /** The file-history blob domain's SQL table (BlobBackend `table`/MinIO index binding + the A7 assert). */
 export declare const FILE_HISTORY_BLOB_TABLE = "file_history_blob";
 /** MinIO object-key prefix for this domain (snapshot epoch used "blobs/"; a separate prefix keeps the
@@ -183,17 +183,18 @@ export declare class PgFileHistoryStore extends SqlFileHistoryStore {
 }
 /**
  * [ref] D1② — A7-recipe upgrade precondition assert (**refuse to start**, never a warn; the form and
- * rationale follow `assertPermissionRuleTicketSchema` verbatim: this repo ships no ALTER TABLE, and
+ * rationale follow `assertPermissionRuleTicketSchema` verbatim: the boot check never alters a table, and
  * `CREATE TABLE IF NOT EXISTS` is a no-op on an existing table whose columns predate this build).
  *
  * The probe is one always-empty `WHERE 1=0` read per table naming every column this build references.
- * ONLY a provable missing-column error gets the destructive recreate guidance — everything else
- * (timeout / reset / permission / missing table) rethrows untouched: advising `DROP TABLE` for a
- * connection blip is more expensive than the defect this gate exists to stop. Honest cost statement:
- * dropping these tables loses per-file REWIND history (working-tree convenience state) — session
- * transcripts and every other durable subsystem are untouched.
+ * ONLY a provable missing-column error gets the missing-column refusal — everything else
+ * (timeout / reset / permission / missing table) rethrows untouched: diagnosing a connection blip as a
+ * schema drift is more expensive than the defect this gate exists to stop. The refusal's ways out are the
+ * closed set of three shared with the whole-database check (`describeProbedTableDrift`); none of them
+ * is destructive. Honest cost statement: the history lives in these tables (per-file REWIND history,
+ * working-tree convenience state) — session transcripts and every other durable subsystem are untouched.
  */
 export declare function assertFileHistorySchema(query: (sql: string) => Promise<{
     rows: Record<string, unknown>[];
-}>, dialect: "tidb" | "pg"): Promise<void>;
+}>, dialect: SqlDialect): Promise<void>;
 //# sourceMappingURL=file-history-store-sql.d.ts.map

package/dist/plugins/file-history-store-sql.js

@@ -3,6 +3,7 @@ import { captureFileBackupViaEnv, applyFileRestoreViaEnv, fileHistoryModeProvenD
 import { BlobTooLargeError, SqlBlobBackend } from "./blob-backend.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isMissingColumnError } from "./sql-errors.js";
+import { describeProbedTableDrift } from "./schema-drift-sentence.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { foldCaughtFailure } from "../file-history-disclosure.js";
 export const FILE_HISTORY_BLOB_TABLE = "file_history_blob";
@@ -32,13 +33,13 @@ export class SqlFileHistoryStore {
         this.db = db;
         this.pool = pool;
         this.blobs = blobBackend ?? new SqlBlobBackend(this.db.dialect, this.pool, undefined, FILE_HISTORY_BLOB_TABLE);
-        this.boundaryKeep = resolveFileHistoryRetention(this.db.dialect === "tidb" ? "TiDBFileHistoryStore" : "PgFileHistoryStore", opts?.retention);
+        this.boundaryKeep = resolveFileHistoryRetention(this.db.dialect === "mysql" ? "TiDBFileHistoryStore" : "PgFileHistoryStore", opts?.retention);
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     bool(v) {
-        return this.db.dialect === "tidb" ? (v ? 1 : 0) : v;
+        return this.db.dialect === "mysql" ? (v ? 1 : 0) : v;
     }
     leaseKey(scope, entryId) {
         return `${scope}\x00${entryId}`;
@@ -835,11 +836,10 @@ export async function assertFileHistorySchema(query, dialect) {
                 throw err;
             throw new Error(`${table} is missing required columns — refusing to start. This build's per-file rewind history (S-15) ` +
                 `references every probed column unconditionally; a partial table would fail mid-write and could publish a ` +
-                `half-shaped history graph. This repository ships no ALTER TABLE migrations, so the table must be recreated: run ` +
-                `\`DROP TABLE ${table};\` on the ${dialect === "pg" ? "PostgreSQL" : "MySQL-protocol"} backend and restart — the ` +
-                `schema is recreated at boot. Cost, honestly stated: dropping file_history_* tables loses per-file REWIND history ` +
-                `(working-tree convenience state); session transcripts and all other durable subsystems are untouched. ` +
-                `Underlying probe error: ${err instanceof Error ? err.message : String(err)}`);
+                `half-shaped history graph. The file_history_* tables hold the per-file REWIND history (working-tree convenience ` +
+                `state); session transcripts and all other durable subsystems are untouched, and an in-place ALTER keeps the history.\n` +
+                `Underlying probe error: ${err instanceof Error ? err.message : String(err)}\n\n` +
+                (await describeProbedTableDrift(query, dialect, [table])));
         }
     }
 }

package/dist/plugins/file-run-store.d.ts

@@ -152,7 +152,7 @@ export declare class FileRunStore implements InProcessClaimFence {
     whileHoldingClaim(sessionId: string, taskId: string, write: () => FenceLanded): boolean;
     getRun(taskId: string): Promise<RunRecord | undefined>;
     /** Undo THIS submission's binding (key + body fingerprint → null) — called only where the submit surface refuses the submission
-     *  before any work and terminalizes the row it just claimed (the sync leg's zero-work refusal, a device-placement reject):
+     *  before any work and terminalizes the row it just claimed (the sync leg's zero-work refusal, an execution-placement reject):
      *  the error answer invites a retry, and a retry with the same key must run, not replay the refusal. The row stays (it
      *  is the refusal's record); only the binding is freed. */
     releaseIdemKey(taskId: string): Promise<void>;
@@ -332,6 +332,11 @@ export declare class FileRunStore implements InProcessClaimFence {
      * 起服时调(`LocalBackend.runOneTimeMigrations`,任何读者之前);数据根独占 ⇒ 本车道没有滚动升级窗,不需要读侧半场。幂等:第二跑零命中零写盘。
      */
     migrateLegacyHolderDeathCodes(): number;
+    /**
+     * 一次性迁移 **M32 的 local 腿**(执行放置回填;窗、删法与删后谁接住:窗口见 `plugins/one-time-migrations.ts` 登记表):有 run 行的会话 id(去重)。
+     * 起服时调(`LocalBackend.runOneTimeMigrations`,任何读者之前);读内存索引(构造时已从盘上 hydrate),零写。
+     */
+    sessionIdsWithRuns(): ReadonlySet<string>;
     /** Release every open event-log fd (called by LocalBackend.close so a graceful restart can re-open the data dir). */
     dispose(): void;
 }

package/dist/plugins/file-run-store.js

@@ -280,6 +280,7 @@ export class FileRunStore {
                     "Refusing to boot with an EMPTY single-active claim index (every session would look unclaimed, so a delete or a fresh run could race a live/parked one). " +
                     "Fix the permissions/mount on that path, point LOCAL_DATA_ROOT at a readable dir, or unset RUN_STORE_STRICT_HYDRATE to boot anyway (the pre-existing behavior).");
             }
+            recordFailOpen("server.run-store.file-active-claims-unreadable", detail);
             claims = [];
         }
         const nonTerminalBySanitizedSession = new Map();
@@ -1009,6 +1010,9 @@ export class FileRunStore {
         }
         return migrated;
     }
+    sessionIdsWithRuns() {
+        return new Set([...this.runs.values()].map((r) => r.sessionId));
+    }
     dispose() {
         for (const log of this.eventLogs.values()) {
             try {

package/dist/plugins/fork-routing-session-store.d.ts

@@ -25,6 +25,8 @@
  */
 import { type SessionStore, type AcquiredSession, type SessionStoreSummary, type SessionPlacement, type PlacedSessionRow } from "@sema-agent/core";
 import { type DelegationTree } from "../delegated-session-owner.js";
+import type { ExecutionPlacementSeat } from "../execution-placement.js";
+import type { ForkToFn } from "./session-fork.js";
 /** acquire 选项形(core 5.48 SessionStore 契约):[ref] placement=受信 spawner 的分区建会话声明。 */
 type AcquireOpts = {
     requireExisting?: boolean;
@@ -54,6 +56,10 @@ export declare class ForkRoutingSessionStore implements SessionStore {
         olderThanMs?: number;
         scope?: string;
     }) => Promise<PlacedSessionRow[]>;
+    /** 执行席透传(host 有才有):执行放置是**根会话行**上的一格,根会话行住 host durable 店;transient 店没有会话行可放,也就不声明席。 */
+    readonly executionPlacement?: ExecutionPlacementSeat;
+    /** fork 续写的店契约透传(host 有才有):目标在 host 店原子新建,新 id 与源一并记 host 路由(与 {@link fork} 的 host 腿同)。 */
+    readonly forkTo?: ForkToFn;
     constructor(host: SessionStore, transient: SessionStore);
     private remember;
     private pick;

package/dist/plugins/fork-routing-session-store.js

@@ -11,6 +11,8 @@ export class ForkRoutingSessionStore {
     placed = new Set();
     placements;
     listPlaced;
+    executionPlacement;
+    forkTo;
     constructor(host, transient) {
         this.host = host;
         this.transient = transient;
@@ -23,6 +25,20 @@ export class ForkRoutingSessionStore {
         if (host.fork === undefined && transient.fork === undefined) {
             this.fork = undefined;
         }
+        const hostFaces = host;
+        if (hostFaces.executionPlacement !== undefined)
+            this.executionPlacement = hostFaces.executionPlacement;
+        const hostForkTo = hostFaces.forkTo;
+        if (typeof hostForkTo === "function") {
+            this.forkTo = async (sourceId, owner, target) => {
+                const out = await hostForkTo.call(host, sourceId, owner, target);
+                if (out !== null && out.outcome !== "occupied") {
+                    this.remember(sourceId, "host");
+                    this.remember(out.id, "host");
+                }
+                return out;
+            };
+        }
     }
     remember(id, where) {
         this.route.delete(id);

package/dist/plugins/image-bake-store-sql.js

@@ -145,7 +145,7 @@ export async function ensurePgImageBakeSchema(pool, poolName = "standard") {
 }
 const isDupKey = isDupKeyError;
 function dupKeyName(dialect, err) {
-    if (dialect === "tidb") {
+    if (dialect === "mysql") {
         const msg = String(err?.sqlMessage ?? err?.message ?? "");
         if (/uq_image_bake_event_line/i.test(msg))
             return "uq_line";
@@ -169,8 +169,8 @@ export class SqlImageBake {
         this.db = db;
         this.poolName = poolName;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     insertParams(bakeId, input, now) {
         return [
@@ -214,7 +214,7 @@ export class SqlImageBake {
         const conn = await this.db.connect();
         let inserted = false;
         try {
-            if (this.db.dialect === "tidb") {
+            if (this.db.dialect === "mysql") {
                 await conn.begin();
                 await conn.query("INSERT INTO image_bake_admit (pool) VALUES (?) ON DUPLICATE KEY UPDATE pool = pool", [this.poolName]);
                 await conn.query("SELECT pool FROM image_bake_admit WHERE pool = ? FOR UPDATE", [this.poolName]);
@@ -255,15 +255,15 @@ export class SqlImageBake {
         return { created: true, bake };
     }
     async getBake(bakeId) {
-        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("tidb")} FROM image_bake WHERE bake_id = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE bake_id = $1 LIMIT 1`), [bakeId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("mysql")} FROM image_bake WHERE bake_id = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE bake_id = $1 LIMIT 1`), [bakeId]);
         return rows[0] ? refusingBakeRow(() => mapRow(rows[0])) : null;
     }
     async getBakeByIdem(idemKey) {
-        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("tidb")} FROM image_bake WHERE idem_key = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE idem_key = $1 LIMIT 1`), [idemKey]);
+        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("mysql")} FROM image_bake WHERE idem_key = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE idem_key = $1 LIMIT 1`), [idemKey]);
         return rows[0] ? refusingBakeRow(() => mapRow(rows[0])) : null;
     }
     async findActiveByArgv(argv) {
-        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("tidb")} FROM image_bake WHERE status IN ('queued','running') AND argv = CAST(? AS JSON) ` +
+        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("mysql")} FROM image_bake WHERE status IN ('queued','running') AND argv = CAST(? AS JSON) ` +
             "ORDER BY created_at DESC LIMIT 1", `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE status IN ('queued','running') AND argv = $1::jsonb ` +
             "ORDER BY created_at DESC LIMIT 1"), [JSON.stringify(argv)]);
         return rows[0] ? refusingBakeRow(() => mapRow(rows[0])) : null;
@@ -380,7 +380,7 @@ export class SqlImageBake {
         return m == null ? 0 : Number(m);
     }
     async getEvents(bakeId, afterSeq) {
-        const { rows } = await this.db.query(this.q(`SELECT seq, line_ord, kind, level, ${jsonColumnText("tidb", "data")}, ts FROM image_bake_event WHERE bake_id = ? AND seq > ? ORDER BY seq ASC`, `SELECT seq, line_ord, kind, level, ${jsonColumnText("pg", "data")}, ts FROM image_bake_event WHERE bake_id = $1 AND seq > $2 ORDER BY seq ASC`), [bakeId, afterSeq]);
+        const { rows } = await this.db.query(this.q(`SELECT seq, line_ord, kind, level, ${jsonColumnText("mysql", "data")}, ts FROM image_bake_event WHERE bake_id = ? AND seq > ? ORDER BY seq ASC`, `SELECT seq, line_ord, kind, level, ${jsonColumnText("pg", "data")}, ts FROM image_bake_event WHERE bake_id = $1 AND seq > $2 ORDER BY seq ASC`), [bakeId, afterSeq]);
         return rows.map((r) => ({
             seq: Number(r.seq),
             lineOrd: r.line_ord === null ? null : Number(r.line_ord),
@@ -401,7 +401,7 @@ export class SqlImageBake {
         await this.tx(async (conn) => {
             const res = await conn.query(this.q("UPDATE image_bake SET status=?, state=?, digest=?, repo=?, ref=?, index_id=?, exit_code=?, error=?, " +
                 "error_code=?, manifest_sha=?, tag=?, ingest_secret=NULL, updated_at=? WHERE bake_id=? AND status IN ('queued','running')", "UPDATE image_bake SET status=$1, state=$2, digest=$3, repo=$4, ref=$5, index_id=$6, exit_code=$7, error=$8, " +
-                "error_code=$9, manifest_sha=$10, tag=$11, ingest_secret=NULL, updated_at=$12 WHERE bake_id=$13 AND status IN ('queued','running')"), this.db.dialect === "tidb" ? this.terminalParamsTidb(bakeId, t) : this.terminalParamsPg(bakeId, t));
+                "error_code=$9, manifest_sha=$10, tag=$11, ingest_secret=NULL, updated_at=$12 WHERE bake_id=$13 AND status IN ('queued','running')"), this.db.dialect === "mysql" ? this.terminalParamsTidb(bakeId, t) : this.terminalParamsPg(bakeId, t));
             affectedRows = res.affected;
             await conn.query(this.q("DELETE FROM image_bake_lease WHERE pool = ? AND bake_id = ?", "DELETE FROM image_bake_lease WHERE pool = $1 AND bake_id = $2"), [this.poolName, bakeId]);
         });

package/dist/plugins/image-index-sql.js

@@ -181,8 +181,8 @@ export class SqlImageIndex {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     static idFor(repo, digest) {
         return createHash("sha256").update(`${repo}@${digest}`).digest("hex").slice(0, 64);
@@ -216,7 +216,7 @@ export class SqlImageIndex {
            status = EXCLUDED.status, visibility = EXCLUDED.visibility, tenant_id = EXCLUDED.tenant_id,
            manifest_sha = EXCLUDED.manifest_sha, recipe_git_sha = EXCLUDED.recipe_git_sha,
            generator_version = EXCLUDED.generator_version, build_date = EXCLUDED.build_date,
-           supersedes = EXCLUDED.supersedes, signed = EXCLUDED.signed, updated_at = EXCLUDED.updated_at`), this.db.dialect === "tidb" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
+           supersedes = EXCLUDED.supersedes, signed = EXCLUDED.signed, updated_at = EXCLUDED.updated_at`), this.db.dialect === "mysql" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
         return id;
     }
     async registerBuilding(e) {
@@ -258,21 +258,21 @@ export class SqlImageIndex {
            supersedes = EXCLUDED.supersedes,
            signed = CASE WHEN sandbox_image_index.status = 'published'
                          THEN sandbox_image_index.signed ELSE EXCLUDED.signed END,
-           updated_at = EXCLUDED.updated_at`), this.db.dialect === "tidb" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
+           updated_at = EXCLUDED.updated_at`), this.db.dialect === "mysql" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
         return id;
     }
     async getById(id) {
-        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index WHERE id=? LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE id = $1 LIMIT 1`), [id]);
+        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index WHERE id=? LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE id = $1 LIMIT 1`), [id]);
         return rows[0] ? refusingImageRow(() => mapRow(rows[0])) : null;
     }
     async getByDigest(digest) {
-        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index WHERE digest=? ORDER BY updated_at DESC LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE digest = $1 ORDER BY updated_at DESC LIMIT 1`), [digest]);
+        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index WHERE digest=? ORDER BY updated_at DESC LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE digest = $1 ORDER BY updated_at DESC LIMIT 1`), [digest]);
         return rows[0] ? refusingImageRow(() => mapRow(rows[0])) : null;
     }
     async latestPublished(profile, viewer) {
-        if (this.db.dialect === "tidb") {
+        if (this.db.dialect === "mysql") {
             const vis = visibilityClauseTidb(viewer);
-            const { rows } = await this.db.query(`SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index
+            const { rows } = await this.db.query(`SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index
           WHERE profile=? AND status='published' AND ${vis.sql}
           ORDER BY (build_date IS NULL), build_date DESC, created_at DESC LIMIT 1`, [profile, ...vis.params]);
             return rows[0] ? refusingImageRow(() => mapRow(rows[0])) : null;
@@ -286,7 +286,7 @@ export class SqlImageIndex {
     async list(filter) {
         const limit = Math.min(Math.max(1, filter.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
         let rawRows;
-        if (this.db.dialect === "tidb") {
+        if (this.db.dialect === "mysql") {
             const vis = visibilityClauseTidb(filter);
             const where = [vis.sql];
             const params = [...vis.params];
@@ -309,7 +309,7 @@ export class SqlImageIndex {
                     params.push(new Date(c.createdAt), new Date(c.createdAt), c.id);
                 }
             }
-            const sql = `SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index WHERE ${where.join(" AND ")} ` +
+            const sql = `SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index WHERE ${where.join(" AND ")} ` +
                 `ORDER BY created_at DESC, id DESC LIMIT ?`;
             const { rows } = await this.db.query(sql, [...params, limit + 1]);
             rawRows = rows;
@@ -359,7 +359,7 @@ export class SqlImageIndex {
         return { entries, nextCursor };
     }
     async setStatus(id, status, opts) {
-        if (this.db.dialect === "tidb") {
+        if (this.db.dialect === "mysql") {
             const sets = ["status=?", "updated_at=?"];
             const params = [status, new Date()];
             if (opts && "supersedes" in opts) {

package/dist/plugins/leader-run-store-sql.js

@@ -95,8 +95,8 @@ export class SqlLeaderRunStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async createRun(input) {
         const id = uuidv7();
@@ -120,12 +120,12 @@ export class SqlLeaderRunStore {
         return { created: true, run };
     }
     async getRun(id) {
-        const res = await this.db.query(this.q(`SELECT ${selectCols("tidb")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = $1`), [id]);
+        const res = await this.db.query(this.q(`SELECT ${selectCols("mysql")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = $1`), [id]);
         const row = res.rows[0];
         return row ? mapRow(row) : undefined;
     }
     async getByIdem(idemKey) {
-        const res = await this.db.query(this.q(`SELECT ${selectCols("tidb")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = $1`), [idemKey]);
+        const res = await this.db.query(this.q(`SELECT ${selectCols("mysql")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = $1`), [idemKey]);
         const row = res.rows[0];
         return row ? mapRow(row) : undefined;
     }