@sema-agent/server 7.133.0 → 7.135.0

package/dist/plugins/caching-session-store.d.ts

@@ -1,35 +1,36 @@
-import type { AcquiredSession, PlacedSessionRow, RetentionDeclaration, SessionPlacementRecord, SessionStore, SessionTreeEntry } from "@sema-agent/core";
+import { type AcquiredSession, type PlacedSessionRow, type RetentionDeclaration, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry } from "@sema-agent/core";
 import type { OwnerAwareSessionStore, SessionListItem } from "../security.js";
 import type { StagingHandle } from "../session-sync-kernel.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import type { InstructionSourceStore } from "../instruction-source-notice.js";
-import type { SessionFaceReader } from "../session-incarnation.js";
 import type { OwnerlessClaim } from "../delegated-session-owner.js";
 export interface CachingOptions {
     /** Idle seconds a woken session is kept warm. 0 disables caching (pure passthrough). */
     ttlSec: number;
     sweepIntervalMs?: number;
-    /** Called once per warm hit that turned out stale (the store's head no longer names the cached leaf, or the session is
-     *  gone): the entry was dropped and the session woken from the store again. Not an error — the operator signal for
+    /** Called once per warm hit that turned out stale (the store's head no longer names the cached occupant and leaf, or the
+     *  session is gone): the entry was dropped and the session woken from the store again. Not an error — the operator signal for
      *  "requests for one session alternate between replicas within the TTL" (the hit rate affinity would buy back). */
     onStaleHit?: (sessionId: string) => void;
 }
-/** The store's current head for one session — the one read every warm hit is checked against (`undefined` = no such
- *  session). The same single-row read `OwnerAwareSessionStore.getHead` names; this cache requires its inner store to have it. */
-export type SessionHeadReader = Required<Pick<OwnerAwareSessionStore, "getHead">>;
+/** The store's current head for one session — core `SessionStore.headOf`, the one by-id read of the row every warm hit is checked
+ *  against (`undefined` = no such session). This cache requires its inner store to have it. */
+export type SessionHeadReader = Required<Pick<SessionStore, "headOf">>;
 /**
  * Warm cache in front of a durable {@link SessionStore}.
  *
  * Keeps a woken session in memory and **reuses the same storage instance across turns**, so an active session is not
  * woken from the store (meta row + event log) on every short turn. Idle sessions expire after `ttlSec`; `release` evicts.
  *
- * **One rule: a warm entry is served only while the store's head for that session still names the leaf the entry
- * holds.** Every hit reads the head first (`getHead` — one primary-key row read on the SQL twins); head gone or leaf
- * moved ⇒ the entry is dropped and the session is woken from the store again ({@link CachingOptions.onStaleHit}). The
- * leaf is the token because it is exactly what the stores' conditional writes compare (`expectedLeafId`): a handle this
- * cache hands out is never behind the store's leaf, so those writes fail only on a genuinely concurrent write — two runs
- * writing one session at the same time. Any number of replicas may share one store under any routing; session affinity
- * only raises the hit rate.
+ * **One rule: a warm entry is served only while the store's head for that session still names the occupant and the leaf
+ * the entry holds.** Every hit reads the head first (`headOf` — one primary-key row read on the SQL twins); head gone, another
+ * occupant (core `compareOccupants` — anything but `same`, `unknown` included), or leaf moved ⇒ the entry is dropped and the
+ * session is woken from the store again ({@link CachingOptions.onStaleHit}). The leaf is half the token because it is exactly
+ * what the stores' conditional writes compare (`expectedLeafId`): a handle this cache hands out is never behind the store's
+ * leaf, so those writes fail only on a genuinely concurrent write — two runs writing one session at the same time. The
+ * occupant is the other half: a row another replica deleted and created again under the same id can stand at the leaf the
+ * entry holds (both empty — `null`), and serving the old view would hand a run the previous occupant's token. Any number of
+ * replicas may share one store under any routing; session affinity only raises the hit rate.
  *
  * Open item (the same before this rule): a write that rewrites history while leaving the final leaf id where it was —
  * a session-sync replace / `overwrite-dst` staged commit on ANOTHER replica that changes entry payloads under the same
@@ -50,17 +51,12 @@ export declare class CachingSessionStore implements SessionStore {
     private readonly ttlMs;
     private readonly timer?;
     private readonly onStaleHit?;
-    /** Delegated tenant-ownership ops, present only if the inner store exposes them (the TiDB store does). */
-    readonly ownerOf?: (sessionId: string) => Promise<string | null | undefined>;
-    /** S-790:属主 + 化身一次读,纯转发(不经暖缓存 —— 化身判的就是「此刻坐在座位上的是谁」,缓存的旧答案正是要消灭的那一形)。
-     *  🔴 必须转发(与 retention / placements / instruction-source 同一条教训):生产默认把真店包进本类,不转发 = parked 决定腿
-     *  与记忆座在默认部署上读不到化身。 */
-    readonly sessionFaceOf?: SessionFaceReader;
-    /** core `SessionStore.incarnationOf`(按 id 读住客)—— 同一条纯转发、同一条理由:答的是行上那一格,绝不从暖缓存里那只会话的元数据答
-     *  (缓存的会话活得比「另一只店删掉又重建了这一行」长)。🔴 必须转发:k8s 工作区空间的每 run 读与起服门读的就是本类。 */
-    readonly incarnationOf?: SessionStore["incarnationOf"];
+    /** core `SessionStore.headOf` —— 按 id 读一行(属主 / 住客 / 叶子)的唯一读口,**纯转发、不经暖缓存**(答的是行,绝不从暖缓存里那只会话的元数据答 ——
+     *  缓存的会话活得比「另一只店删掉又重建了这一行」长)。内层店必有(本类的暖命中按它核新鲜)。🔴 必须转发:生产默认把真店包进本类,授权口 / 属主门 /
+     *  parked 两读 / k8s 工作区空间 / SSE 探针 / resume-at 读的都是本类。 */
+    readonly headOf: SessionHeadReader["headOf"];
     readonly register?: (sessionId: string, owner: string | null) => Promise<void>;
-    /** S-1770 委派继承律的认领口,纯转发(写的是行上的属主那一格 —— 只 CAS 子行自己,不碰暖缓存里的会话;停驻挂点在默认部署上读的就是本类 —— 与 `placementOf` 同转发同缺:内店记录委派树 ⇒ 两只都在)。 */
+    /** [ref] 委派继承律的认领口,纯转发(写的是行上的属主那一格 —— 只 CAS 子行自己,不碰暖缓存里的会话;停驻挂点在默认部署上读的就是本类 —— 与 `placementOf` 同转发同缺:内店记录委派树 ⇒ 两只都在)。 */
     readonly claimOwnerless?: OwnerlessClaim;
     /** Delegated SessionRepo seam (§0.5) — list/fork/delete operate on the DURABLE tables directly (they bypass the
      *  warm cache by design; a fork/delete must read/write durable state, not a possibly-stale cached view). */
@@ -84,16 +80,11 @@ export declare class CachingSessionStore implements SessionStore {
     /** The auto-titler's NULL-only title write (SQL twins + local sidecar carry it; pure pass-through). */
     readonly setTitleIfNull?: (sessionId: string, title: string) => Promise<boolean>;
     readonly probeTitle?: (sessionId: string) => Promise<"none" | "untitled" | "titled">;
-    /** S-690 —— 换源通告的基线面(`session_meta.instruction_source` / local sidecar),纯转发、不经暖缓存。
+    /** [ref] —— 换源通告的基线面(`session_meta.instruction_source` / local sidecar),纯转发、不经暖缓存。
      *  🔴 必须转发(与 retention / placements 同一条教训):默认 `SESSION_CACHE_TTL_SEC=300` 把真店包进本类,
      *  而装配点按「店上两个方法都在」判席 —— 不转发 = 默认部署上换源通告**静默不发**,且没有任何一处报错。 */
     readonly readInstructionSource?: InstructionSourceStore["readInstructionSource"];
     readonly recordInstructionSource?: InstructionSourceStore["recordInstructionSource"];
-    /** E18 — delegate the leaf read straight to inner (a cache-bypassing single SELECT; the resume-at turn-capture
-     *  reads the DURABLE leaf, not a possibly-stale cached view — same discipline as the §0.5 repo ops above). */
-    readonly getLeafId?: (sessionId: string) => Promise<string | null>;
-    /** [ref] 六轮复审:owner+leafId 原子快照透传(cache-bypassing,getLeafId 同姿势)。内层店必有(本类的暖命中按它核新鲜)。 */
-    readonly getHead: SessionHeadReader["getHead"];
     /** 2c session-sync — delegated export/import seam, DURABLE (bypasses the warm cache exactly like
      *  list/fork: an export reads the full durable log, an import writes durable state). */
     readonly exportEntries?: (sessionId: string) => Promise<SessionTreeEntry[] | null>;
@@ -154,9 +145,9 @@ export declare class CachingSessionStore implements SessionStore {
     touch(sessionId: string): Promise<void>;
     release(sessionId: string): Promise<void>;
     /**
-     * The cache's one rule: the warm entry for `sessionId`, if the store's head still names the leaf it holds; otherwise
-     * the entry is dropped (counted once via `onStaleHit`) and `undefined` sends the caller to the store. The head is read
-     * first, the cached leaf second: a write this replica commits in between can only turn a fresh verdict into a stale
+     * The cache's one rule: the warm entry for `sessionId`, if the store's head still names the occupant and the leaf it holds;
+     * otherwise the entry is dropped (counted once via `onStaleHit`) and `undefined` sends the caller to the store. The head is
+     * read first, the cached view second: a write this replica commits in between can only turn a fresh verdict into a stale
      * one (an extra wake), never the reverse.
      */
     private freshHit;

package/dist/plugins/caching-session-store.js

@@ -1,4 +1,5 @@
-import { assertPlacementAdmission } from "./session-placement.js";
+import { admitSessionPlacement, compareOccupants } from "@sema-agent/core";
+import { placementCapabilityOf } from "./session-placement.js";
 export class CachingSessionStore {
     inner;
     cache = new Map();
@@ -6,9 +7,7 @@ export class CachingSessionStore {
     ttlMs;
     timer;
     onStaleHit;
-    ownerOf;
-    sessionFaceOf;
-    incarnationOf;
+    headOf;
     register;
     claimOwnerless;
     listSessions;
@@ -20,8 +19,6 @@ export class CachingSessionStore {
     probeTitle;
     readInstructionSource;
     recordInstructionSource;
-    getLeafId;
-    getHead;
     exportEntries;
     listEntryIds;
     exportEntriesStream;
@@ -38,7 +35,7 @@ export class CachingSessionStore {
         this.inner = inner;
         this.ttlMs = Math.max(0, opts.ttlSec) * 1000;
         this.onStaleHit = opts.onStaleHit;
-        this.getHead = inner.getHead.bind(inner);
+        this.headOf = inner.headOf.bind(inner);
         const declared = inner.retention;
         if (declared !== undefined)
             this.retention = declared;
@@ -50,12 +47,6 @@ export class CachingSessionStore {
         if (typeof innerPlacementOf === "function")
             this.placementOf = (id) => innerPlacementOf.call(inner, id);
         const ownerAware = inner;
-        if (ownerAware.ownerOf)
-            this.ownerOf = ownerAware.ownerOf.bind(inner);
-        if (ownerAware.sessionFaceOf)
-            this.sessionFaceOf = ownerAware.sessionFaceOf.bind(inner);
-        if (typeof inner.incarnationOf === "function")
-            this.incarnationOf = inner.incarnationOf.bind(inner);
         if (ownerAware.register)
             this.register = ownerAware.register.bind(inner);
         if (ownerAware.claimOwnerless)
@@ -76,8 +67,6 @@ export class CachingSessionStore {
             this.recordInstructionSource = ownerAware.recordInstructionSource.bind(inner);
         if (ownerAware.fork)
             this.fork = ownerAware.fork.bind(inner);
-        if (ownerAware.getLeafId)
-            this.getLeafId = ownerAware.getLeafId.bind(inner);
         if (ownerAware.exportEntries)
             this.exportEntries = ownerAware.exportEntries.bind(inner);
         if (ownerAware.listEntryIds)
@@ -144,7 +133,7 @@ export class CachingSessionStore {
         }
         const hit = await this.freshHit(sessionId);
         if (hit && opts?.requireExisting !== true && this.placements !== undefined && this.placementOf !== undefined) {
-            assertPlacementAdmission(sessionId, await this.placementOf(sessionId), opts);
+            admitSessionPlacement(sessionId, await this.placementOf(sessionId), opts ?? {}, placementCapabilityOf(this));
         }
         if (hit) {
             hit.expiresAt = Date.now() + this.ttlMs;
@@ -159,7 +148,7 @@ export class CachingSessionStore {
         if (inflight) {
             const acquired = await inflight;
             if (this.placements !== undefined && this.placementOf !== undefined) {
-                assertPlacementAdmission(sessionId, await this.placementOf(sessionId), opts);
+                admitSessionPlacement(sessionId, await this.placementOf(sessionId), opts ?? {}, placementCapabilityOf(this));
             }
             return acquired;
         }
@@ -187,8 +176,8 @@ export class CachingSessionStore {
         const hit = this.cache.get(sessionId);
         if (hit === undefined)
             return undefined;
-        const head = await this.inner.getHead(sessionId);
-        if (head !== undefined && head.leafId === (await hit.acquired.session.getLeafId()))
+        const head = await this.inner.headOf(sessionId);
+        if (head !== undefined && compareOccupants(head, await hit.acquired.session.getMetadata()) === "same" && head.leafId === (await hit.acquired.session.getLeafId()))
             return hit;
         if (this.cache.get(sessionId) === hit)
             this.cache.delete(sessionId);

package/dist/plugins/checkpoint-index-columns.d.ts

@@ -0,0 +1,81 @@
+/**
+ * `checkpoint` 表的**索引列**:怎么写(一只派生)、到期 facet 怎么从列上读(一只生成谓词)。SQL 两孪生的写口(`checkpoint-store-sql.ts` `put`)、
+ * 一次性迁移 M29 的存量回填(`one-time-migrations.ts`)与到期两条腿(`reapExpired` / `listExpiredApprovalGates`)都只读本模块。
+ *
+ * ## 写:一只派生 = core `checkpointIndexFacts(cp)`(core 7.55.0 [ref] P1 阶段二)
+ * 行上「core 铸下、此后不动」的十三个事实(令牌、scope、会话、格式版本、门型、卡、待决工具的名 / 调用 id / 入参摘要、deadline、铸行时刻、风险描述符、
+ * 双向控制字符在场位),每一个都由 core 那一只函数答;本模块只把它们落到列名下({@link buildCheckpointIndexCells})。修前写口自己从寄存行 / 门上逐格读,
+ * 对任何寄存臂、任何门都不分臂 —— 与 core 读法在契约外的行上答两样(计划门上的卡、审阅寄存行上的工具位)。键表对 core 的事实键闭合
+ * ({@link CHECKPOINT_INDEX_COLUMNS} `satisfies Record<keyof CheckpointIndexFacts, …>`):core 加 / 删一个事实 ⇒ 编译红,由人决定它落不落列。
+ * 不在这里的:CAS 面推动的状态(`status` / `rev` / `reopen_reason` / 执行记录)、部署铸的值(`terminal_at_ms` 兜底)、部署截长脱敏的展示投影(`tool_input` /
+ * `rule_suggestions`)—— 它们不是行的不变事实,core 也不答。
+ *
+ * ## 读:到期 facet 是由 core 两张表**生成**的一条 SQL 表达式
+ * facet = 部署收割器对一行的 deadline 的读法(`A` = 审批门,deadline 是 SLA 拒;`B` = 无人值守 TTL,到期作废;`-` = 非门停驻)。core 的判官是
+ * `facetOf(gate)`:门上的卡是 `CARD_FACET_OVERRIDES` 的键 ⇒ 那个键的 facet,否则门型在 `PAUSE_REGISTRY` 的 `facet` 列。列上存的是卡词本身
+ * (`approval_card`,不是 facet —— 存一份 facet 会在 core 改表那天陈旧),谓词由那两张表机械生成({@link CHECKPOINT_FACET_CASES} → {@link CHECKPOINT_FACET_SQL}),
+ * 逐行与 `facetOf` 同答(`test/checkpoint-index-columns.test.ts` B 节、db 组同名文件)。本仓不写第二份判据:没有手写门型表、没有手写卡词。
+ * 卡那一侧不带「是不是审批门」的合取:列上的卡只在审批门上非 NULL(同一只派生),与 core 对生成谓词的成文形逐字相同。未登记门型 / NULL 门型 ⇒ 表达式 NULL(无 ELSE)。
+ *
+ * ## 谓词什么时候开
+ * core 的迁移条款:存量行的卡列由同一只函数回填,并且只在部署自己记下「回填跑完了」之后才开生成谓词。本仓的记录 = 起服序列:M29 跑在一次性迁移段
+ * (`boot/stores.ts`,先于任何路由与收割器装配),跑不完就拒启 —— 所以每只副本的收割器只在本次起服的 M29 完成之后才运行。混跑期间旧副本新写的行
+ * 不带卡列(它们不认这一列),由下一次起服的 M29 补上;升级序见 MIGRATION 7.135.0 节(同一只库不混跑两版)。
+ */
+import { PAUSE_REGISTRY, type Checkpoint, type CheckpointIndexFacts, type GateKind, type RiskDescriptor } from "@sema-agent/core";
+import type { SqlDialect } from "./sql-driver.js";
+/** 每个索引事实落在哪一列(键表对 core 的事实键闭合:core 加 / 删一个事实 ⇒ 编译红)。 */
+export declare const CHECKPOINT_INDEX_COLUMNS: {
+    readonly token: "token";
+    readonly scope: "scope";
+    readonly sessionId: "session_id";
+    readonly version: "version";
+    readonly gateKind: "gate_kind";
+    readonly approvalCard: "approval_card";
+    readonly toolName: "tool_name";
+    readonly toolCallId: "tool_call_id";
+    readonly boundInputHash: "bound_input_hash";
+    readonly deadline: "deadline";
+    readonly createdAt: "created_at_ms";
+    readonly riskDescriptor: "risk_descriptor";
+    readonly hasBidiControls: "has_bidi_controls";
+};
+type IndexColumnOf<K extends keyof CheckpointIndexFacts> = (typeof CHECKPOINT_INDEX_COLUMNS)[K];
+/**
+ * 一行的索引列格:core 的事实落在列名下。值逐字是事实本身,只有一处换形:双向控制字符在场位落 `1` 或 NULL(列是 TINYINT / SMALLINT,恒不写 0 —— core 的契约
+ * 是「`true` 或缺席」,0 会把「没检出」谎成「已确认干净」)。描述符是行自己的对象,写口负责编码(两方言的 JSON 编码器不同)。
+ */
+export type CheckpointIndexCells = {
+    readonly [K in keyof CheckpointIndexFacts as IndexColumnOf<K>]: K extends "hasBidiControls" ? 1 | null : K extends "riskDescriptor" ? RiskDescriptor | null : CheckpointIndexFacts[K];
+};
+/** 一行的索引列格(纯数据;写口与 M29 回填同调这一只 —— 回填不另读门子树自算)。 */
+export declare function buildCheckpointIndexCells(cp: Checkpoint): CheckpointIndexCells;
+/**
+ * `approval_card` 列放得下的卡词**字节数**(UTF-8 字节,不是字符数),按方言各一格(键表对 {@link SqlDialect} 闭合:加一种方言 ⇒ 编译红)。
+ * MySQL 协议(TiDB / MySQL)的列型是 `TEXT`,上限 65,535 字节 —— 严格模式下超长写入抛 `Data too long`,非严格模式静默截成半只卡词;PG 的 `TEXT` 没有这个上限。
+ * 列型的属主是中央 DDL(`tidb-pool.ts` / `pg-pool.ts` 的 `approval_card`),本表只是那一列的容量事实(`test/checkpoint-index-columns.test.ts` 把两处同读,换列型 ⇒ 红)。
+ * 引擎照存集外词、长度不由本仓定,但引擎铸得出的卡词是闭集短词 —— 超出容量的只会是手改 / 外来写者写下的存量行;读它的是 M29 回填(超出 ⇒ 计数 + 点名跳过,不挡起服)。
+ */
+export declare const APPROVAL_CARD_COLUMN_MAX_BYTES: Readonly<Record<SqlDialect, number>>;
+/** facet 的词(core 登记表 `facet` 列的值域)。 */
+type Facet = (typeof PAUSE_REGISTRY)[GateKind]["facet"];
+/** 生成谓词的一条 WHEN:某一列的值落在这几个词里 ⇒ 这个 facet。 */
+export interface FacetCase {
+    readonly column: typeof CHECKPOINT_INDEX_COLUMNS.approvalCard | typeof CHECKPOINT_INDEX_COLUMNS.gateKind;
+    readonly words: readonly string[];
+    readonly facet: Facet;
+}
+/**
+ * 生成谓词的 WHEN 表:先卡(`CARD_FACET_OVERRIDES` 的键 ⇒ 它的 facet),后门型(`PAUSE_REGISTRY` 每一行 ⇒ 它的 `facet` 列)。第一条命中的赢;都不中 ⇒ NULL。
+ * 纯数据,只由 core 那两张表生成 —— 零手写词。
+ */
+export declare const CHECKPOINT_FACET_CASES: readonly FacetCase[];
+/**
+ * 一行的到期 facet,按方言各一份(同一张 WHEN 表):`CASE WHEN approval_card IN (…) THEN 'B' WHEN gate_kind IN (…) THEN 'A' … END`(无 ELSE ⇒ 未登记门型读 NULL)。
+ * 两份的差别只在「列怎么比」:引擎按**字节**认词(`'question '` 是集外词),而 MySQL 协议表的 `utf8mb4_bin` 是 PAD SPACE 排序(比较时忽略尾空格,`'question '` = `'question'`)
+ * ⇒ 那一方言两列按 `CAST(… AS BINARY)` 比(变长二进制串逐字节比,不补位);PG 的 `varchar` / `text` 比较本来不补位,列原样。
+ * 列名不带表限定:两条读腿都只查 `checkpoint` 一张表。拒扫腿读 `= 'A'`,收割的作废分支读 `COALESCE(…, '') <> 'A'`(NULL 门型的行走作废,与修前同向)。
+ */
+export declare const CHECKPOINT_FACET_SQL: Readonly<Record<SqlDialect, string>>;
+export {};
+//# sourceMappingURL=checkpoint-index-columns.d.ts.map

package/dist/plugins/checkpoint-index-columns.js

@@ -0,0 +1,62 @@
+import { CARD_FACET_OVERRIDES, PAUSE_REGISTRY, checkpointIndexFacts } from "@sema-agent/core";
+export const CHECKPOINT_INDEX_COLUMNS = {
+    token: "token",
+    scope: "scope",
+    sessionId: "session_id",
+    version: "version",
+    gateKind: "gate_kind",
+    approvalCard: "approval_card",
+    toolName: "tool_name",
+    toolCallId: "tool_call_id",
+    boundInputHash: "bound_input_hash",
+    deadline: "deadline",
+    createdAt: "created_at_ms",
+    riskDescriptor: "risk_descriptor",
+    hasBidiControls: "has_bidi_controls",
+};
+export function buildCheckpointIndexCells(cp) {
+    const f = checkpointIndexFacts(cp);
+    return {
+        token: f.token,
+        scope: f.scope,
+        session_id: f.sessionId,
+        version: f.version,
+        gate_kind: f.gateKind,
+        approval_card: f.approvalCard,
+        tool_name: f.toolName,
+        tool_call_id: f.toolCallId,
+        bound_input_hash: f.boundInputHash,
+        deadline: f.deadline,
+        created_at_ms: f.createdAt,
+        risk_descriptor: f.riskDescriptor,
+        has_bidi_controls: f.hasBidiControls === true ? 1 : null,
+    };
+}
+export const APPROVAL_CARD_COLUMN_MAX_BYTES = {
+    tidb: 65_535,
+    pg: Number.POSITIVE_INFINITY,
+};
+function groupByFacet(pairs, column) {
+    const groups = new Map();
+    for (const [word, facet] of pairs) {
+        const words = groups.get(facet);
+        if (words === undefined)
+            groups.set(facet, [word]);
+        else
+            words.push(word);
+    }
+    return [...groups].map(([facet, words]) => ({ column, words, facet }));
+}
+export const CHECKPOINT_FACET_CASES = [
+    ...groupByFacet(Object.entries(CARD_FACET_OVERRIDES), CHECKPOINT_INDEX_COLUMNS.approvalCard),
+    ...groupByFacet(Object.keys(PAUSE_REGISTRY).map((k) => [k, PAUSE_REGISTRY[k].facet]), CHECKPOINT_INDEX_COLUMNS.gateKind),
+];
+const literal = (word) => `'${word.replace(/'/g, "''")}'`;
+function renderFacetCase(compared) {
+    return `CASE ${CHECKPOINT_FACET_CASES.map((c) => `WHEN ${compared(c.column)} IN (${c.words.map(literal).join(", ")}) THEN ${literal(c.facet)}`).join(" ")} END`;
+}
+export const CHECKPOINT_FACET_SQL = Object.freeze({
+    tidb: renderFacetCase((column) => `CAST(${column} AS BINARY)`),
+    pg: renderFacetCase((column) => column),
+});
+//# sourceMappingURL=checkpoint-index-columns.js.map