@sema-agent/server 7.53.0 → 7.55.0

package/dist/plugins/approval-ask-store-sql.d.ts

@@ -241,6 +241,58 @@ export interface ExpireResult {
     won: boolean;
     voidedSiblings: string[];
 }
+/**
+ * [ref](DEBTS [ref]-R1 终局;core [ref] §4.4「@server 对表键形」,黑板 [ref] 认领):终局 claim 的
+ * 意图。ask 行的 TERMINAL 对儿只有两员 —— `expire`(窗到期 / emit 全灭共用:STREAM_PENDING→PARKING +
+ * 批转投递面 + 兄弟撤卡,与 `expireAsk` 同一台 CAS 机器)与 `cancel`(取消臂:STREAM_PENDING→VOID)。
+ * **人答臂(decide)不入本枚举**:`decideAsk` 带决议载荷与回决幂等键,其失败臂本就携行读数(384 §4.4
+ * 表「decideAsk(人答臂)」格的「视现有 CAS 形」裁定)——三 verb 的「一台机器义务」(384 §4.3-2)由共享
+ * WHERE 谓词 {@link pendingClaimWhere} 兑现,不是把三个不同 verb 塞进一个函数。
+ */
+export type AskTerminalClaimIntent = "expire" | "cancel";
+/**
+ * 败方读数:行上终局相关列的一致投影(status 词表 = 行自己的 `AskState`,零新值域 —— 384 §4.2 的
+ * 「reuse the row's own vocabulary」)。
+ *  · `state:"absent"` = 行不在,**或 scope(batchId)不匹配** —— 错 scope 的 claim 必须输且不得读出
+ *    他 scope 行的真相(读谓词与 CAS 谓词是同一份 scope WHERE;多租户隔离,384 §4.2 absent 臂原话)。
+ *  · **绝无 `STREAM_PENDING` 臂**:server 的 ask 店 CAS 谓词是 status 门(STREAM_PENDING→终态),无
+ *    rev/OCC 期望语义 ⇒ core 表的 `pending`(rev 失配)臂在本形结构不可达,如实缺席不硬造([ref]
+ *    补充确认①)。输 = 行在 claim 线性化点上已非 pending,而非 pending 态在状态机上**无回边**
+ *    (`approval-ask-machine.ts`,本域无 reopen)⇒ 败方读数恒 ≥ 那一刻;「CAS 时行不在、读时刚被
+ *    ensureAsk 插入」的编排错序形按线性化点真相投影为 `absent`。
+ *  · 本域无 reopen ⇒ DECIDED 恒不回 pending,败方读数在本域退化为永恒真相;消费仍按快照律
+ *    (384 §4.3-5)写,不依赖此强化([ref] 补充确认②)。
+ */
+export type AskTerminalClaimCurrent = {
+    state: "absent";
+} | {
+    state: Exclude<AskState, "STREAM_PENDING">;
+    rev: number;
+    decision: AskDecision | null;
+    /** [ref] 三态读法照 {@link AskRow.updatedInput}:键缺席 = 没带编辑;`null` 是编辑成 null 的值。 */
+    updatedInput?: unknown;
+};
+/**
+ * 单次原子往返的答案(语义律的唯一规范陈述点 = core `checkpoint-store.ts` `claimTerminal` 契约 JSDoc,
+ * [ref] §4.3;本类型是其 ask 行同位物,不复述七律,只记 server 侧特有形):
+ *  · 赢 ⇒ `{claimed:true}`(expire 意图随赢携兄弟撤卡名单,与 `expireAsk` 同形);
+ *  · 输 ⇒ **同一原子单元**携行真相(律 1)—— 消费方拿到 `claimed:false` 后永不需要第二次读来行动;
+ *  · reject(throw / 超墙钟)⇒ 什么也不证明(律 3 K2)——调用方不得按本地意图宣告终局;**迟到的
+ *    settle 同样自足**:deadline 过后才回来的 `claimed:false` 直接携真决议,臂按真决议 settle 零补读。
+ * server 三臂全为**幂等消费**(按真决议 settle,谁写的无关,律 4)——本店无职责性消费面。
+ */
+export type AskTerminalClaimOutcome = {
+    claimed: true;
+    voidedSiblings: string[];
+} | {
+    claimed: false;
+    current: AskTerminalClaimCurrent;
+};
+/**
+ * 败方读数的投影(三 twin 共用一份,别各自挑列):`null` / 错 scope 由调用方先折成 `null` 传入;
+ * `STREAM_PENDING` 折 `absent` 的理由见 {@link AskTerminalClaimCurrent} 顶注(线性化点真相)。
+ */
+export declare function projectAskTerminalClaimTruth(row: AskRow | null): AskTerminalClaimCurrent;
 export interface BindGateInput {
     gateToken: string;
     gateBoundCallId?: string | null;
@@ -278,6 +330,15 @@ export interface ApprovalAskStore {
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * [ref]:原子终局 claim —— 把「争终局」与「读真相」并成**一次**店往返(胜负判定与败方 `current` 读数
+     * 在同一原子单元内,语义见 {@link AskTerminalClaimOutcome})。[ref]-R1 的病根「CAS 与读真相是两次店
+     * 往返」由本原语从机制上消灭:settle 的答案自足(赢 ⇒ 赢;输 ⇒ 携真相),迟到的答案同样自足。
+     * 律 2「一台机器义务」:`expireAsk` 在本方法之上实现(SQL 双方言)/ 本方法委托给
+     * `expireAsk`/`transitionAsk`(InMemory,单线程天然原子)——两向都成立的判据是**没有第二套谓词**。
+     * 方法**必备**(本仓自有三形全实现,无 core 那侧的 presence 探测问题)。
+     */
+    claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent): Promise<AskTerminalClaimOutcome>;
     expireAsk(askId: string, batchId: string): Promise<ExpireResult>;
     bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;
     abortBatch(batchId: string): Promise<string[]>;
@@ -435,6 +496,27 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * [ref] 原子终局 claim(接口契约见 {@link ApprovalAskStore.claimTerminal};类型语义见
+     * {@link AskTerminalClaimOutcome})。expire 意图 = 既有 `expireAsk` 事务**原体**(步⓪-③ 逐字保留,
+     * `expireAsk` 现在是本方法的薄投影 —— 律 2 的「在 claimTerminal 之上实现」半场);cancel 意图 =
+     * 取消臂的 STREAM_PENDING→VOID(此前走通用 `transitionAsk`,无败方读数)。
+     *
+     * **原子性证明(两方言各一句,红先钉在 db-integration 的 [ref] 组)**:
+     *  · 败方读数是**同一事务内**的 `SELECT … FOR UPDATE` —— TiDB 侧本事务显式 `BEGIN PESSIMISTIC`
+     *    (`beginPessimistic()`,不赌部署的 `tidb_txn_mode` 缺省):悲观锁定读是 CURRENT read,读到的是
+     *    并发赢家**已提交**的最新版本(乐观模式下 FOR UPDATE 读 start_ts 快照,会把赢家终局读旧 ——
+     *    正是 bindBatch 失败臂注记的那类方言分歧,这里用显式事务模式把它结构性关死);PG 侧
+     *    `beginPessimistic()` = 普通 `BEGIN`,READ COMMITTED 下 FOR UPDATE 本就等待并返回最新已提交版本。
+     *  · CAS 输(affected=0)⇒ 行在 UPDATE 那一刻已非 STREAM_PENDING(或不在/错 scope),而非 pending 态
+     *    在状态机上无回边 ⇒ 锁定读读到的恒 ≥ 线性化点,且 DECIDED 决议不可变 —— 答案自足。
+     *  · 本事务在输臂上除批行 rev 自增外零写,rollback 无痕。
+     */
+    claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent): Promise<AskTerminalClaimOutcome>;
+    /** [ref] 起 = {@link claimTerminal}(expire 意图)的薄投影 —— 律 2「在 claimTerminal 之上实现」的
+     *  SQL 半场落笔处:谓词/事务/兄弟撤卡全在 claim 里,这里零第二套写路径。败方读数按既有返回形丢弃
+     *  (`ExpireResult` 不携真相 —— 要真相的调用方直接用 claimTerminal;对账收敛器的 orphan 腿输了本就
+     *  只需「不赢」这一位)。 */
     expireAsk(askId: string, batchId: string): Promise<ExpireResult>;
     bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;
     abortBatch(batchId: string): Promise<string[]>;

package/dist/plugins/approval-ask-store-sql.js

@@ -33,6 +33,16 @@ async function withReadSignal(op, signal, where) {
             signal.removeEventListener("abort", onAbort);
     }
 }
+export function projectAskTerminalClaimTruth(row) {
+    if (row === null || row.state === "STREAM_PENDING")
+        return { state: "absent" };
+    return {
+        state: row.state,
+        rev: row.rev,
+        decision: row.decision,
+        ...(row.updatedInput !== undefined ? { updatedInput: row.updatedInput } : {}),
+    };
+}
 export const APPROVAL_ASK_TABLE = "approval_ask";
 export const APPROVAL_BATCH_TABLE = "approval_batch";
 export const TIDB_APPROVAL_ASK_STATEMENTS = [
@@ -278,6 +288,9 @@ function patchColumns(patch, json) {
 function ph(dialect, n) {
     return dialect === "tidb" ? "?" : `$${n}`;
 }
+function pendingClaimWhere(dialect, firstParam) {
+    return `ask_id = ${ph(dialect, firstParam)} AND batch_id = ${ph(dialect, firstParam + 1)} AND state = 'STREAM_PENDING'`;
+}
 export class SqlApprovalAskStore {
     db;
     constructor(db) {
@@ -366,6 +379,7 @@ export class SqlApprovalAskStore {
         if (decision.idempotencyKey != null)
             assertIdempotencyKeyShape(decision.idempotencyKey);
         const now = Date.now();
+        const dialect = this.db.dialect;
         const conn = await this.db.connect();
         try {
             await conn.begin();
@@ -376,7 +390,7 @@ export class SqlApprovalAskStore {
             }
             let askRes;
             try {
-                askRes = await conn.query(this.q(`UPDATE ${APPROVAL_ASK_TABLE} SET state='DECIDED', decision=?, decision_actor=?, decision_note=?, updated_input=?, decided_at_ms=?, idempotency_key=?, rev=rev+1, updated_at_ms=? WHERE ask_id=? AND state='STREAM_PENDING'`, `UPDATE ${APPROVAL_ASK_TABLE} SET state='DECIDED', decision=$1, decision_actor=$2, decision_note=$3, updated_input=$4, decided_at_ms=$5, idempotency_key=$6, rev=rev+1, updated_at_ms=$7 WHERE ask_id=$8 AND state='STREAM_PENDING'`), [
+                askRes = await conn.query(`UPDATE ${APPROVAL_ASK_TABLE} SET state='DECIDED', decision=${ph(dialect, 1)}, decision_actor=${ph(dialect, 2)}, decision_note=${ph(dialect, 3)}, updated_input=${ph(dialect, 4)}, decided_at_ms=${ph(dialect, 5)}, idempotency_key=${ph(dialect, 6)}, rev=rev+1, updated_at_ms=${ph(dialect, 7)} WHERE ${pendingClaimWhere(dialect, 8)}`, [
                     decision.decision,
                     decision.decisionActor == null ? null : this.json(decision.decisionActor),
                     decision.decisionNote ?? null,
@@ -385,6 +399,7 @@ export class SqlApprovalAskStore {
                     decision.idempotencyKey ?? null,
                     now,
                     askId,
+                    batchId,
                 ]);
             }
             catch (err) {
@@ -416,20 +431,32 @@ export class SqlApprovalAskStore {
             throw new Error(`decideAsk: row vanished after commit (askId=${askId})`);
         return { ok: true, row };
     }
-    async expireAsk(askId, batchId) {
+    async claimTerminal(askId, batchId, intent) {
+        const to = intent === "expire" ? "PARKING" : "VOID";
+        if (!canAskTransition("STREAM_PENDING", to)) {
+            throw new Error(`approval-ask-store.claimTerminal: illegal terminal claim STREAM_PENDING -> ${to} (askId=${askId})`);
+        }
         const now = Date.now();
+        const dialect = this.db.dialect;
         const conn = await this.db.connect();
         try {
-            await conn.begin();
-            const lockRes = await conn.query(this.q(`UPDATE ${APPROVAL_BATCH_TABLE} SET rev=rev+1 WHERE batch_id=?`, `UPDATE ${APPROVAL_BATCH_TABLE} SET rev=rev+1 WHERE batch_id=$1`), [batchId]);
-            if (lockRes.affected !== 1) {
-                await conn.rollback();
-                return { won: false, voidedSiblings: [] };
+            await conn.beginPessimistic();
+            if (intent === "expire") {
+                const lockRes = await conn.query(this.q(`UPDATE ${APPROVAL_BATCH_TABLE} SET rev=rev+1 WHERE batch_id=?`, `UPDATE ${APPROVAL_BATCH_TABLE} SET rev=rev+1 WHERE batch_id=$1`), [batchId]);
+                if (lockRes.affected !== 1) {
+                    await conn.rollback();
+                    return { claimed: false, current: { state: "absent" } };
+                }
             }
-            const askRes = await conn.query(this.q(`UPDATE ${APPROVAL_ASK_TABLE} SET state='PARKING', rev=rev+1, updated_at_ms=? WHERE ask_id=? AND state='STREAM_PENDING'`, `UPDATE ${APPROVAL_ASK_TABLE} SET state='PARKING', rev=rev+1, updated_at_ms=$1 WHERE ask_id=$2 AND state='STREAM_PENDING'`), [now, askId]);
+            const askRes = await conn.query(`UPDATE ${APPROVAL_ASK_TABLE} SET state = ${ph(dialect, 1)}, rev = rev + 1, updated_at_ms = ${ph(dialect, 2)} WHERE ${pendingClaimWhere(dialect, 3)}`, [to, now, askId, batchId]);
             if (askRes.affected !== 1) {
+                const sel = await conn.query(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ${ph(dialect, 1)} AND batch_id = ${ph(dialect, 2)} FOR UPDATE`, [askId, batchId]);
                 await conn.rollback();
-                return { won: false, voidedSiblings: [] };
+                return { claimed: false, current: projectAskTerminalClaimTruth(sel.rows[0] ? mapAskRow(sel.rows[0]) : null) };
+            }
+            if (intent === "cancel") {
+                await conn.commit();
+                return { claimed: true, voidedSiblings: [] };
             }
             await conn.query(this.q(`UPDATE ${APPROVAL_BATCH_TABLE} SET state='ROUTING_UNBOUND', rev=rev+1, updated_at_ms=? WHERE batch_id=? AND state='OPEN'`, `UPDATE ${APPROVAL_BATCH_TABLE} SET state='ROUTING_UNBOUND', rev=rev+1, updated_at_ms=$1 WHERE batch_id=$2 AND state='OPEN'`), [now, batchId]);
             let voidedSiblings;
@@ -449,7 +476,7 @@ export class SqlApprovalAskStore {
                 }
             }
             await conn.commit();
-            return { won: true, voidedSiblings };
+            return { claimed: true, voidedSiblings };
         }
         catch (err) {
             try {
@@ -463,6 +490,10 @@ export class SqlApprovalAskStore {
             conn.release();
         }
     }
+    async expireAsk(askId, batchId) {
+        const res = await this.claimTerminal(askId, batchId, "expire");
+        return res.claimed ? { won: true, voidedSiblings: res.voidedSiblings } : { won: false, voidedSiblings: [] };
+    }
     async bindBatch(batchId, askId, gate) {
         const now = Date.now();
         const conn = await this.db.connect();

package/dist/plugins/device-store-sql.d.ts

@@ -44,7 +44,7 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type SqlDriver } from "./sql-driver.js";
-import { type AcquireConnectionInput, type AcquireConnectionResult, type AppendAuditInput, type BindSessionInput, type BindSessionResult, type ConsumeEnrollTokenInput, type ConsumeEnrollTokenResult, type DeviceAdmissionView, type DeviceAuditRow, type DeviceEnrollTokenRow, type DeviceOwner, type DeviceRow, type DeviceSessionRow, type DeviceStore, type HeartbeatConnectionInput, type IssueEnrollTokenInput, type ListAuditFilter, type RevokeDeviceInput, type RevokeDeviceResult } from "../device-store.js";
+import { type AcquireConnectionInput, type AcquireConnectionResult, type AppendAuditInput, type BindSessionInput, type BindSessionResult, type ConsumeEnrollTokenInput, type ConsumeEnrollTokenResult, type DeviceAdmissionView, type DeviceAuditRow, type DeviceEnrollTokenRow, type DeviceOwner, type DeviceRow, type DeviceSessionRow, type DeviceStore, type HeartbeatConnectionInput, type IssueEnrollTokenInput, type ListAuditFilter, type RebindSessionInput, type RebindSessionResult, type RevokeDeviceInput, type RevokeDeviceResult } from "../device-store.js";
 /**
  * ── 命名(**落库一律单数**,与设计稿的复数形不同)──────────────────────────────────────────────────
  * design v2 §6 的 DDL 写的是 `devices` / `device_sessions` / `device_enrollment_tokens`(复数),但本仓有一条
@@ -62,6 +62,29 @@ export declare const TIDB_DEVICE_STATEMENTS: readonly string[];
 export declare function ensureTiDBDeviceSchema(pool: MySqlPool): Promise<void>;
 type PgQuery = (sql: string, params?: unknown[]) => Promise<unknown>;
 export declare function ensurePgDeviceSchema(q: PgQuery): Promise<void>;
+/**
+ * O4 升级前置探针 —— **拒启,不是 warn**([ref]/[ref]/[ref] `assert*Schema` 族先例):`device_audit` 的
+ * 事件闭集加了第 9 员 `session_rebound`,而 `CREATE TABLE IF NOT EXISTS` 对存量表是空操作 ⇒ 一台没
+ * 重建表就升上来的 **PG** 部署(PG 强制 CHECK;TiDB 默认 `tidb_enable_check_constraint=OFF` 不执行,
+ * 见 AUDIT_EVENT_CHECK 头注的真库实测),每一次换绑赢 CAS 都在**审计 INSERT** 上撞
+ * `ck_device_audit_event` ⇒ 整事务回滚,换绑动词在运行期恒 500 —— 而启动与健康检查全绿。
+ *
+ * 判据 = **能力探测**(begin → 插一行 `session_rebound` → rollback,探针行永不落地),不读
+ * information_schema 元数据(memory `capability-detection-not-impl-names`:判「装没装」用能力面 ——
+ * TiDB 上 CHECK 元数据在而不执行,读元数据会把能写的表误判成不能写)。只有**可证**的 CHECK 拒
+ * ({@link isCheckViolationError})才换成指路;其余错误原样上抛([ref] 两轮收窄的同一条:一句指向
+ * 手工 DDL 的指路比它要挡的缺陷更贵)。
+ *
+ * 🔴 指路刻意**不是** `DROP TABLE`(与兄弟探针不同):`device_audit` 是安全轴审计史,为扩一个词表
+ * 销毁全部审计行不成比例。本仓不发 `ALTER TABLE`(SCHEMA POLICY),但闭集执法的权威本就在应用层
+ * (读侧 `parseDeviceAuditEvent`),CHECK 只是纵深 —— 所以给运维的是**手工**约束级重建语句
+ * (drop + 按当前闭集 add),历史一行不丢,纵深回到当前词表。
+ *
+ * 调用点:`boot/stores.ts`,**只在 device 车道真会装配时探**(`config.remoteExec?.provider ===
+ * "device"`,与 main.ts 的 `createDeviceLane` 谓词同源)——非 device 部署零审计写点,为它拒启是纯误伤
+ * ([ref] round2 的同一条收窄)。
+ */
+export declare function assertDeviceAuditRebindEventSchema(db: SqlDriver): Promise<void>;
 export declare class SqlDeviceStore implements DeviceStore {
     private readonly db;
     constructor(db: SqlDriver);
@@ -82,6 +105,8 @@ export declare class SqlDeviceStore implements DeviceStore {
     readDeviceForAdmission(deviceId: string, owner: DeviceOwner): Promise<DeviceAdmissionView | null>;
     getDeviceUnscoped(deviceId: string): Promise<DeviceRow | null>;
     listDevicesByOwner(owner: DeviceOwner): Promise<DeviceRow[]>;
+    /** O4/S-4 operator 全量(消费点必须先过 explicit operator 门 —— 契约注见 `DeviceStore`)。 */
+    listDevicesUnscoped(): Promise<DeviceRow[]>;
     /**
      * 吊销 = 终态 CAS(`status='active'` 前态)+ **租约作废 + 世代推进**(§8-R4 在途语义):
      * 世代一推,在途连接的每一次带世代谓词的写(心跳/结果帧入账)当场影响 0 行 ⇒ 设备侧立即失权。
@@ -113,6 +138,18 @@ export declare class SqlDeviceStore implements DeviceStore {
      * 输家回读既有行 —— 同 deviceId = 幂等成功,异 deviceId = `conflict`(无未定义态)。
      */
     bindSession(input: BindSessionInput): Promise<BindSessionResult>;
+    /**
+     * O4 显式换绑(2026-08-30 v2 稿 §2)—— **单事务**:目标设备门(当前读)+ 幂等短路 + 前态 CAS +
+     * `session_rebound` 审计行一起提交。三形语义 oracle = `InMemoryDeviceStore.rebindSession`。
+     *
+     * 🔴 `beginPessimistic` + 两次 `FOR UPDATE`(bindSession 的同一条真库红的射程):
+     *  · 设备行必须当前读 —— 快照读会把「与吊销并发的换绑」绑到一台刚被吊销的设备上(double-admit 形);
+     *  · 绑定行必须当前读且**持锁到提交** —— 两个并发换绑(同 expectedRev)在锁上串行:赢家 rev+1 提交,
+     *    输家的锁读看到新 rev ⇒ 走 `rev_conflict` 携当前行(单赢家,无未定义态)。锁读判等之后,CAS
+     *    UPDATE(`rev = ?` 谓词 + `rev+1` 恒变列)在持锁下不可能 0 行 —— 0 行即驱动/引擎异常,响亮抛,
+     *    不折成业务分支([ref]:未知失败不伪装成正常拒绝)。
+     */
+    rebindSession(input: RebindSessionInput): Promise<RebindSessionResult>;
     getSessionBinding(rootSessionId: string): Promise<DeviceSessionRow | null>;
     deleteByRootSession(rootSessionId: string): Promise<number>;
     appendAudit(input: AppendAuditInput): Promise<void>;

package/dist/plugins/device-store-sql.js

@@ -1,6 +1,6 @@
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
-import { isDupKeyError } from "./sql-errors.js";
-import { DEVICE_AUDIT_EVENTS, assertAcquireShape, assertDeviceIdShape, assertDeviceOwnerShape, assertEnrollTokenHashShape, assertIssueTokenShape, assertNewDeviceShape, assertRevokeShape, assertRootSessionIdShape, assertWholeSeconds, parseDeviceAuditEvent, parseDevicePlatformOs, parseDeviceStatus, } from "../device-store.js";
+import { isDupKeyError, isCheckViolationError } from "./sql-errors.js";
+import { DEVICE_AUDIT_EVENTS, assertAcquireShape, assertDeviceIdShape, assertDeviceOwnerShape, assertEnrollTokenHashShape, assertIssueTokenShape, assertNewDeviceShape, assertRebindShape, assertRevokeShape, assertRootSessionIdShape, assertWholeSeconds, parseDeviceAuditEvent, parseDevicePlatformOs, parseDeviceStatus, } from "../device-store.js";
 export const DEVICES_TABLE = "device";
 export const DEVICE_ENROLL_TOKENS_TABLE = "device_enroll_token";
 export const DEVICE_SESSIONS_TABLE = "device_session";
@@ -149,6 +149,39 @@ export async function ensurePgDeviceSchema(q) {
     await q(`CREATE INDEX IF NOT EXISTS idx_device_audit_device ON ${DEVICE_AUDIT_TABLE} (device_id, at)`);
     await q(`CREATE INDEX IF NOT EXISTS idx_device_audit_event ON ${DEVICE_AUDIT_TABLE} (event, at)`);
 }
+export async function assertDeviceAuditRebindEventSchema(db) {
+    const conn = await db.connect();
+    try {
+        await conn.begin();
+        try {
+            await conn.query(db.dialect === "tidb"
+                ? `INSERT INTO ${DEVICE_AUDIT_TABLE} (at, event, device_id, owner_tenant, owner_subject, detail) VALUES (NOW(3), ?, NULL, NULL, NULL, NULL)`
+                : `INSERT INTO ${DEVICE_AUDIT_TABLE} (at, event, device_id, owner_tenant, owner_subject, detail) VALUES (now(), $1, NULL, NULL, NULL, NULL)`, ["session_rebound"]);
+        }
+        catch (err) {
+            if (!isCheckViolationError(err, db.dialect))
+                throw err;
+            const remedy = db.dialect === "pg"
+                ? `ALTER TABLE ${DEVICE_AUDIT_TABLE} DROP CONSTRAINT ck_device_audit_event; ALTER TABLE ${DEVICE_AUDIT_TABLE} ADD CONSTRAINT ck_device_audit_event CHECK (event IN (${AUDIT_EVENT_CHECK}));`
+                : `ALTER TABLE ${DEVICE_AUDIT_TABLE} DROP CHECK ck_device_audit_event; ALTER TABLE ${DEVICE_AUDIT_TABLE} ADD CONSTRAINT ck_device_audit_event CHECK (event IN (${AUDIT_EVENT_CHECK}));`;
+            throw new Error(`${DEVICE_AUDIT_TABLE} still carries a pre-O4 event CHECK that rejects 'session_rebound' — refusing to start. ` +
+                "The rebind verb (POST /v1/devices/sessions/:rootSessionId/rebind) writes this audit event in the same transaction " +
+                "as its CAS, so on this table every rebind would fail at runtime after a healthy-looking boot. This repository ships " +
+                "no ALTER TABLE migrations, and dropping an AUDIT table would destroy security-axis history — run the manual " +
+                `constraint rebuild instead (history preserved, defense-in-depth restored to the current closed set): \`${remedy}\` ` +
+                "The application layer remains the enforcing authority for this closed set (parseDeviceAuditEvent). " +
+                `Underlying probe error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await conn.rollback();
+    }
+    catch (err) {
+        await conn.rollback().catch(() => undefined);
+        throw err;
+    }
+    finally {
+        conn.release();
+    }
+}
 const ms = (dialect, col, alias) => dialect === "tidb" ? `ROUND(UNIX_TIMESTAMP(${col}) * 1000) AS ${alias}` : `(EXTRACT(EPOCH FROM ${col}) * 1000)::bigint AS ${alias}`;
 const NOW = (dialect) => (dialect === "tidb" ? "NOW(3)" : "now()");
 const nowPlusSeconds = (dialect, placeholder) => dialect === "tidb" ? `NOW(3) + INTERVAL ${placeholder} SECOND` : `now() + (${placeholder}::double precision * INTERVAL '1 second')`;
@@ -413,6 +446,10 @@ export class SqlDeviceStore {
         const { rows } = await this.db.query(this.q(`SELECT ${deviceCols("tidb")} FROM ${DEVICES_TABLE} WHERE owner_tenant = ? AND owner_subject = ? ORDER BY device_id ASC`, `SELECT ${deviceCols("pg")} FROM ${DEVICES_TABLE} WHERE owner_tenant = $1 AND owner_subject = $2 ORDER BY device_id ASC`), [owner.tenant, owner.subject]);
         return rows.map(mapDeviceRow);
     }
+    async listDevicesUnscoped() {
+        const { rows } = await this.db.query(this.q(`SELECT ${deviceCols("tidb")} FROM ${DEVICES_TABLE} ORDER BY device_id ASC`, `SELECT ${deviceCols("pg")} FROM ${DEVICES_TABLE} ORDER BY device_id ASC`));
+        return rows.map(mapDeviceRow);
+    }
     async revokeDevice(input) {
         assertRevokeShape(input);
         const conn = await this.db.connect();
@@ -515,6 +552,49 @@ export class SqlDeviceStore {
             conn.release();
         }
     }
+    async rebindSession(input) {
+        assertRebindShape(input);
+        const conn = await this.db.connect();
+        try {
+            await conn.beginPessimistic();
+            const dev = await conn.query(this.q(`SELECT status FROM ${DEVICES_TABLE} WHERE device_id = ? AND owner_tenant = ? AND owner_subject = ? FOR UPDATE`, `SELECT status FROM ${DEVICES_TABLE} WHERE device_id = $1 AND owner_tenant = $2 AND owner_subject = $3 FOR UPDATE`), [input.toDeviceId, input.owner.tenant, input.owner.subject]);
+            if (!dev.rows[0] || parseDeviceStatus(bufToStr(dev.rows[0].status)) !== "active") {
+                await conn.rollback();
+                return { outcome: "device_not_found" };
+            }
+            const cur = await conn.query(this.q(`SELECT ${sessionCols("tidb")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = ? AND owner_tenant = ? AND owner_subject = ? FOR UPDATE`, `SELECT ${sessionCols("pg")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = $1 AND owner_tenant = $2 AND owner_subject = $3 FOR UPDATE`), [input.rootSessionId, input.owner.tenant, input.owner.subject]);
+            if (!cur.rows[0]) {
+                await conn.rollback();
+                return { outcome: "binding_not_found" };
+            }
+            const row = mapSessionRow(cur.rows[0]);
+            if (row.deviceId === input.toDeviceId && row.rev === input.expectedRev) {
+                await conn.rollback();
+                return { outcome: "idempotent", row };
+            }
+            if (row.rev !== input.expectedRev) {
+                await conn.rollback();
+                return { outcome: "rev_conflict", row };
+            }
+            const cas = await conn.query(this.q(`UPDATE ${DEVICE_SESSIONS_TABLE} SET device_id = ?, bound_at = NOW(3), rev = rev + 1 WHERE root_session_id = ? AND owner_tenant = ? AND owner_subject = ? AND rev = ?`, `UPDATE ${DEVICE_SESSIONS_TABLE} SET device_id = $1, bound_at = now(), rev = rev + 1 WHERE root_session_id = $2 AND owner_tenant = $3 AND owner_subject = $4 AND rev = $5`), [input.toDeviceId, input.rootSessionId, input.owner.tenant, input.owner.subject, input.expectedRev]);
+            if (cas.affected !== 1) {
+                throw new Error(`device-store: rebind CAS affected ${cas.affected} rows under a held row lock — engine anomaly, refusing to guess`);
+            }
+            await this.insertAuditOn(conn, { event: "session_rebound", deviceId: input.toDeviceId, owner: row.owner, detail: { from: row.deviceId, to: input.toDeviceId, rev: row.rev + 1 } });
+            const { rows } = await conn.query(this.q(`SELECT ${sessionCols("tidb")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = ?`, `SELECT ${sessionCols("pg")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = $1`), [input.rootSessionId]);
+            await conn.commit();
+            if (!rows[0])
+                throw new Error("device-store: rebound session binding vanished inside its own transaction");
+            return { outcome: "rebound", row: mapSessionRow(rows[0]) };
+        }
+        catch (err) {
+            await conn.rollback().catch(() => undefined);
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+    }
     async getSessionBinding(rootSessionId) {
         assertRootSessionIdShape(rootSessionId);
         const { rows } = await this.db.query(this.q(`SELECT ${sessionCols("tidb")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = ?`, `SELECT ${sessionCols("pg")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = $1`), [rootSessionId]);

package/dist/plugins/pg-pool.d.ts

@@ -39,9 +39,36 @@ export declare const PG_SCHEMA_STATEMENTS: readonly string[];
  *  Unset = both off (byte-compat: legit heavyweight statements — boot DDL, ≤64 MiB snapshot-blob rows — make a
  *  universal default unsafe; the S9 write-behind counter face carries its own always-on per-query timeout). */
 export declare function pgPoolOptions(pgCfg: NonNullable<ServiceConfig["pg"]>, dbQueryTimeoutMs?: number): pg.PoolConfig;
+/** 池连接错误的结构化摘要([ref];idle 态与 checked-out 态两监听共用)。纯函数,单测直打。字段
+ *  **诚实缺席**:code/severity 只在错误对象上真有 string 值时才出键(pg 的 DatabaseError 把两者
+ *  平铺在错误对象上;裸网络错误没有)—— 不 String() 硬铸,「不知道 ≠ 铸一个假值」([ref] 同族纪律)。 */
+export interface PgPoolClientErrorMeta {
+    message: string;
+    code?: string;
+    severity?: string;
+}
+export declare function pgPoolClientErrorMeta(err: unknown): PgPoolClientErrorMeta;
+/** `createPgPool` 的 warn 座(形=store-backend 的 `BootLogSink`;不 import 它——那是反向依赖)。 */
+export type PgPoolWarnSink = (msg: string, meta?: Record<string, unknown>) => void;
 /** Create the PG pool from a connection string (or pg.PoolConfig). Thin — production backend-selection wiring
- *  (a ServiceConfig.pg sibling of .tidb) is a tracked follow-on. */
-export declare function createPgPool(opts: string | pg.PoolConfig): pg.Pool;
+ *  (a ServiceConfig.pg sibling of .tidb) is a tracked follow-on.
+ *
+ *  ── [ref](DEBTS;test [ref] 独立复现 FATAL 57P01→exit)——池必须挂 'error' 监听 ─────────────────
+ *  node-postgres 语义(pg-pool@3.14.0 `makeIdleListener`):一条**空闲**连接出错
+ *  (`pg_terminate_backend` / 云端故障切换 / LB 空闲回收 / 网络断)⇒ 池先 `_remove(client)` 再
+ *  `pool.emit('error', err, client)`。Pool 是 EventEmitter ⇒ 无 'error' 监听时 Node 把这枚事件转
+ *  throw(ERR_UNHANDLED_ERROR)⇒ `boot/shutdown.ts` 的 uncaughtException 钩无条件 exit 1 ⇒
+ *  **一条空闲连接的死换整进程的死**。修在源头监听,三件明确**不做**:
+ *   · 不 exit —— 坏连接在 emit **之前**已被池淘汰,下次 acquire 发新连接,在飞查询(在别的
+ *     client 上)零影响,这不是进程级故障;
+ *   · 不静默 —— 每次事件一条结构化 warn(含 code/severity)+ `recordFailOpen`(F 类,census 第
+ *     52 行):「连接不断被外部杀」(故障切换风暴 / 回收策略过激)与「一切正常」在服务面同形,
+ *     不留痕则只能靠间接症状发现;
+ *   · 不动 shutdown.ts 的 uncaughtException 钩 —— exit 1 对**真**未捕获仍是正确姿势,旁路兜底
+ *     会吞掉别人的崩溃([ref] 纪律:修源头,不下游兜)。
+ *  `onIdleClientError` 缺省 console.warn(与本文件 `ensurePgSchema` 的既有告警姿势一致)——生产
+ *  装配(store-backend `createStoreBackend`)递结构化 logger 的 warn 座。 */
+export declare function createPgPool(opts: string | pg.PoolConfig, onIdleClientError?: PgPoolWarnSink): pg.Pool;
 /** Idempotent central schema apply (the PG twin of tidb-pool.ts ensureSchema): the run/checkpoint tables here +
  *  every PG store's own (disjoint) tables. Order is irrelevant (CREATE IF NOT EXISTS, no cross-table FKs).
  *

package/dist/plugins/pg-pool.js

@@ -1,4 +1,5 @@
 import pg from "pg";
+import { recordFailOpen } from "../observability/fail-open.js";
 import { ensureSchema as ensureSessionSchema } from "./pg-session-storage.js";
 import { ensureSchema as ensureToolResultSchema } from "./tool-result-store-sql.js";
 import { ensureSchema as ensureCostQuotaSchema } from "./pg-cost-quota.js";
@@ -341,8 +342,50 @@ export function pgPoolOptions(pgCfg, dbQueryTimeoutMs) {
         ...(dbQueryTimeoutMs ? { statement_timeout: dbQueryTimeoutMs, query_timeout: dbQueryTimeoutMs + 5_000 } : {}),
     };
 }
-export function createPgPool(opts) {
-    return typeof opts === "string" ? new pg.Pool({ connectionString: opts }) : new pg.Pool(opts);
+export function pgPoolClientErrorMeta(err) {
+    const bag = typeof err === "object" && err !== null ? err : {};
+    return {
+        message: err instanceof Error ? err.message : String(err),
+        ...(typeof bag.code === "string" ? { code: bag.code } : {}),
+        ...(typeof bag.severity === "string" ? { severity: bag.severity } : {}),
+    };
+}
+export function createPgPool(opts, onIdleClientError) {
+    const pool = typeof opts === "string" ? new pg.Pool({ connectionString: opts }) : new pg.Pool(opts);
+    const warn = onIdleClientError ?? ((msg, meta) => console.warn(`[pg-pool] ${msg}`, meta));
+    const report = (msgName, state, err, count) => {
+        const meta = pgPoolClientErrorMeta(err);
+        try {
+            warn(msgName, { ...meta });
+        }
+        catch {
+        }
+        if (!count)
+            return;
+        const firstLine = meta.message.split("\n", 1)[0] ?? "";
+        recordFailOpen("server.pg-pool.idle-client-error", `state=${state} ${meta.code ?? "uncoded"}/${meta.severity ?? "?"} ${firstLine.slice(0, 200)}`);
+    };
+    pool.on("error", (err) => report("pg_pool_idle_client_error", "idle", err, true));
+    const checkoutGuards = new WeakMap();
+    pool.on("acquire", (client) => {
+        if (checkoutGuards.has(client))
+            return;
+        let counted = false;
+        const guard = (err) => {
+            report("pg_pool_checked_out_client_error", "checked-out", err, !counted);
+            counted = true;
+        };
+        checkoutGuards.set(client, guard);
+        client.on("error", guard);
+    });
+    pool.on("release", (_err, client) => {
+        const guard = checkoutGuards.get(client);
+        if (guard !== undefined) {
+            client.removeListener("error", guard);
+            checkoutGuards.delete(client);
+        }
+    });
+    return pool;
 }
 const ENSURE_SCHEMA_LOCK_KEY = 4906;
 export async function ensurePgSchema(pool) {

package/dist/plugins/remote-env-device.d.ts

@@ -1,5 +1,5 @@
 import { ExecutionError, FileError, RemoteExecutionError, type ExecutionEnv, type ExecutionEnvFactory, type ExecStreamOptions, type FileInfo, type OutputChunk, type RemoteConnectConfig, type RemoteExecutionEnv, type Result, type SessionToken, type SnapshotId, type VmLifecycleOptions, type WorkspaceHandle, type WriteExpectation, type WriteReceipt } from "@sema-agent/core";
-import { DEVICE_RATE_LIMIT_CODE, type DeviceErrorCode, type DeviceOwner, type DeviceRow, type DeviceStore } from "../device-store.js";
+import { type DeviceOwner, type DeviceRejectCode, type DeviceRow, type DeviceStore } from "../device-store.js";
 import type { DeviceEnrollment } from "../device-enrollment.js";
 import type { DeviceWsHub } from "../device-ws-hub.js";
 import type { DeviceInstructionKind, DeviceOutcomeErrorCode } from "../device-ws-protocol.js";
@@ -34,7 +34,7 @@ export declare const DEVICE_OUTCOME_TO_FILE_ERROR: Readonly<Record<DeviceOutcome
  * **从未启动**,因为可执行面解析不了」,与「设备没有这条指令面」同侧;never-started 语义保住)。
  */
 export declare const DEVICE_OUTCOME_TO_EXEC_ERROR: Readonly<Record<DeviceOutcomeErrorCode, ExecutionError["code"]>>;
-type RejectCode = DeviceErrorCode | typeof DEVICE_RATE_LIMIT_CODE;
+type RejectCode = DeviceRejectCode;
 /**
  * 汇聚端的 **typed 拒**(投递门**之前**,§5.3 投递边界:设备从未可能见过这条指令)→ core 错误码。
  *
@@ -44,6 +44,8 @@ type RejectCode = DeviceErrorCode | typeof DEVICE_RATE_LIMIT_CODE;
  * 例外 `identity_mismatch` / `revoked` / `not_found`:那是**永久**拒(换设备/吊销/不是你的),重试
  * 只会同样失败 —— exec 面落 `auth_failed`(NEVER retry 的那一格),file 面无对位词落 `permission_denied`
  * (「这条路你走不通,而且不是暂时的」是它最近的语义)。
+ * `draining`([ref] 借用位)与 busy 同侧(commit 前拒,从未启动)—— 判别靠 rejectText 把 `[draining]`
+ * 整句带进文案:重试该去**替换副本**,不是稍后打同一个。
  */
 export declare const DEVICE_REJECT_TO_EXEC_ERROR: Readonly<Record<RejectCode, ExecutionError["code"]>>;
 export declare const DEVICE_REJECT_TO_FILE_ERROR: Readonly<Record<RejectCode, FileError["code"]>>;

package/dist/plugins/remote-env-device.js

@@ -1,6 +1,6 @@
 import { posix } from "node:path";
 import { ExecutionError, FileError, RemoteExecutionError, } from "@sema-agent/core";
-import { DEVICE_ERROR_CODES, DEVICE_RATE_LIMIT_CODE, } from "../device-store.js";
+import { DEVICE_ERROR_CODES, } from "../device-store.js";
 export const DEVICE_PROVIDER = "device";
 const ok = (value) => ({ ok: true, value });
 const STREAM_PENDING_MAX_BYTES = 2 * 1024 * 1024;
@@ -59,7 +59,10 @@ export const DEVICE_REJECT_TO_EXEC_ERROR = {
     "device.revoked": "auth_failed",
     "device.enrollment_invalid": "auth_failed",
     "not_found.device": "auth_failed",
+    "device.rebind_rev_conflict": "target_unavailable",
+    "device.rebind_active_run": "target_unavailable",
     "limit.rate_exceeded": "target_unavailable",
+    "draining": "target_unavailable",
 };
 export const DEVICE_REJECT_TO_FILE_ERROR = {
     "device.not_bound": "transport_lost",
@@ -72,7 +75,10 @@ export const DEVICE_REJECT_TO_FILE_ERROR = {
     "device.revoked": "permission_denied",
     "device.enrollment_invalid": "permission_denied",
     "not_found.device": "permission_denied",
+    "device.rebind_rev_conflict": "transport_lost",
+    "device.rebind_active_run": "transport_lost",
     "limit.rate_exceeded": "transport_lost",
+    "draining": "transport_lost",
 };
 const DEVICE_REJECT_TO_REMOTE_ERROR = {
     "device.not_bound": "connect_failed",
@@ -85,7 +91,10 @@ const DEVICE_REJECT_TO_REMOTE_ERROR = {
     "device.revoked": "auth_failed",
     "device.enrollment_invalid": "auth_failed",
     "not_found.device": "auth_failed",
+    "device.rebind_rev_conflict": "connect_failed",
+    "device.rebind_active_run": "connect_failed",
     "limit.rate_exceeded": "connect_failed",
+    "draining": "connect_failed",
 };
 function rejectText(reject) {
     return `[${reject.code}] ${reject.message}`;
@@ -172,7 +181,7 @@ export class RemoteDeviceExecutionEnv {
         if (admitted.value.deviceId !== this.cfg.deviceId) {
             return {
                 ok: false,
-                error: new RemoteExecutionError("auth_failed", `[${DEVICE_ERROR_CODES.IDENTITY_MISMATCH}] this session is now bound to a different device than the one this environment was minted for — refusing to silently re-target (device lane identity, v2 §4.5)`),
+                error: new RemoteExecutionError("auth_failed", `[${DEVICE_ERROR_CODES.IDENTITY_MISMATCH}] this session is now bound to a different device (${admitted.value.deviceId}) than the one this environment was minted for — refusing to silently re-target; re-initiate the work on the currently bound device (device lane identity, v2 §4.5/§3)`),
             };
         }
         {
@@ -236,6 +245,7 @@ export class RemoteDeviceExecutionEnv {
         const input = {
             rootSessionId: this.cfg.rootSessionId,
             requester: this.cfg.owner,
+            expectedDeviceId: this.cfg.deviceId,
             kind,
             args,
             timeoutMs: opts.timeoutMs,

package/dist/plugins/roster-store-sql.d.ts

@@ -21,8 +21,7 @@
  * 是「core 变语义必须先过迁移裁量」的告警钉)。
  */
 import type { Pool } from "mysql2/promise";
-import { type RosterStore, type RosterEntry } from "@sema-agent/core";
-type RosterAccess = Parameters<RosterStore["resolve"]>[1];
+import { type RosterStore, type RosterEntry, type RosterAccess } from "@sema-agent/core";
 import type { PgQueryFn } from "./pg-query.js";
 export declare const ROSTER_TABLE = "agent_roster";
 export declare function ensureTiDBRosterSchema(pool: Pool): Promise<void>;
@@ -51,5 +50,4 @@ export declare class PgRosterStore implements RosterStore {
     /** [ref] MED2(TiDB twin 同案注)。 */
     reapOlderThan(cutoffMs: number): Promise<number>;
 }
-export {};
 //# sourceMappingURL=roster-store-sql.d.ts.map

package/dist/plugins/sql-errors.d.ts

@@ -56,4 +56,16 @@ export declare const MYSQL_ER_BAD_FIELD_CODE = "ER_BAD_FIELD_ERROR";
  * MySQL 侧两个归因键都认(mysql2 的 `code`/`errno` 是同一件事的两种写法),与 dup-key 那条同姿势。
  */
 export declare function isMissingColumnError(err: unknown, dialect: SqlDialect): boolean;
+/** PostgreSQL `check_violation` 的 SQLSTATE。 */
+export declare const PG_CHECK_VIOLATION_SQLSTATE = "23514";
+/** MySQL/TiDB `ER_CHECK_CONSTRAINT_VIOLATED` 的数字 errno(TiDB 仅在 `tidb_enable_check_constraint=ON` 时可达)。 */
+export declare const MYSQL_ER_CHECK_VIOLATED_ERRNO = 3819;
+/** MySQL/TiDB `ER_CHECK_CONSTRAINT_VIOLATED` 的字符串错误码。 */
+export declare const MYSQL_ER_CHECK_VIOLATED_CODE = "ER_CHECK_CONSTRAINT_VIOLATED";
+/**
+ * 「这个错误**是**『CHECK 约束被拒』吗」—— O4 `device_audit` 事件闭集升级探针
+ * (`assertDeviceAuditRebindEventSchema`)的唯一判据。收窄纪律与 {@link isMissingColumnError} 逐字同源:
+ * 它守的是一句**指向手工 DDL 的**错误指路,认不出的一律不是 CHECK 拒(原始错误原样上抛)。
+ */
+export declare function isCheckViolationError(err: unknown, dialect: SqlDialect): boolean;
 //# sourceMappingURL=sql-errors.d.ts.map

package/dist/plugins/sql-errors.js

@@ -25,4 +25,14 @@ export function isMissingColumnError(err, dialect) {
         return keyOf(err, "code") === PG_UNDEFINED_COLUMN_SQLSTATE;
     return keyOf(err, "errno") === MYSQL_ER_BAD_FIELD_ERRNO || keyOf(err, "code") === MYSQL_ER_BAD_FIELD_CODE;
 }
+export const PG_CHECK_VIOLATION_SQLSTATE = "23514";
+export const MYSQL_ER_CHECK_VIOLATED_ERRNO = 3819;
+export const MYSQL_ER_CHECK_VIOLATED_CODE = "ER_CHECK_CONSTRAINT_VIOLATED";
+export function isCheckViolationError(err, dialect) {
+    if (err === null || typeof err !== "object")
+        return false;
+    if (dialect === "pg")
+        return keyOf(err, "code") === PG_CHECK_VIOLATION_SQLSTATE;
+    return keyOf(err, "errno") === MYSQL_ER_CHECK_VIOLATED_ERRNO || keyOf(err, "code") === MYSQL_ER_CHECK_VIOLATED_CODE;
+}
 //# sourceMappingURL=sql-errors.js.map