@lunora/d1 0.0.0 → 1.0.0-alpha.2

package/dist/index.d.ts

@@ -0,0 +1,339 @@
+import { SchemaLike, DatabaseWriterLike } from '@lunora/do';
+import { SqlCtxDbOptions, createSqlCtxDb, SqlCtxExec, readSqlCdcChanges, SqlDialect } from '@lunora/sql-store';
+export { type SqlCtxExec as D1Exec, type SqlCtxDbOptions, type SqlCtxExec, createSqlCtxDb } from '@lunora/sql-store';
+import { BatchItem, BatchResponse } from 'drizzle-orm/batch';
+import { DrizzleD1Database } from 'drizzle-orm/d1';
+/** The D1 store options — the shared store options minus `dialect` (the SQLite dialect is injected for you). */
+type D1ContextDatabaseOptions = Omit<SqlCtxDbOptions, "dialect">;
+/** Build a D1-backed `.global()` writer (the shared store core bound to the SQLite dialect). */
+declare const createD1ContextDatabase: (options: D1ContextDatabaseOptions) => ReturnType<typeof createSqlCtxDb>;
+/** Auto-provision the schema's `.global()` tables in D1 (idempotent `CREATE TABLE IF NOT EXISTS`). */
+declare const runD1GlobalTableMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
+/** Materialize the `__agg_&lt;index>` companion tables for the schema's aggregate indexes. */
+declare const runD1AggregateMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
+/** Materialize the `__rank_&lt;index>` companion tables for the schema's rank indexes. */
+declare const runD1RankMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
+/** Materialize the `__fts_&lt;index>` fts5 shadow tables for the schema's search indexes (no-op without fts5). */
+declare const runD1SearchMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
+/** Create the `__cdc_log` table in D1 (idempotent; only run when CDC is enabled). */
+declare const runD1CdcMigration: (exec: SqlCtxExec) => Promise<void>;
+/** Read changelog entries newer than `sinceSeq` in commit order. */
+declare const readD1CdcChanges: (exec: SqlCtxExec, options?: {
+  limit?: number;
+  sinceSeq?: number;
+}) => ReturnType<typeof readSqlCdcChanges>;
+/** Drop changelog entries at or below a checkpointed `throughSeq`. */
+declare const trimD1CdcChanges: (exec: SqlCtxExec, throughSeq: number) => Promise<void>;
+/** One exported row: `doc` is reconstructed from the column tuple. */
+interface ExportRow {
+  doc: Record<string, unknown>;
+  table: string;
+}
+interface ImportError {
+  code: string;
+  line: number;
+  message: string;
+  table: string;
+}
+interface ImportResult {
+  /** Skipped rows whose `_id` already exists. */
+  conflicts: number;
+  errors: ImportError[];
+  inserted: Record<string, number>;
+}
+/**
+* Return every `.global()` table in the schema, optionally narrowed by an
+* allowlist. Shard-local tables are skipped here — they're handled by the DO
+* helpers — so callers get a clean separation between the two storage planes.
+*/
+declare const selectGlobalTables: (schema: SchemaLike, requested?: ReadonlyArray<string>) => string[];
+interface ExportGlobalArgs {
+  batchSize?: number;
+  tables?: ReadonlyArray<string>;
+}
+/**
+* Yield rows from every requested `.global()` table in batches. Uses
+* `LIMIT ?/OFFSET ?` because D1 globals don't have a stable keyset abstraction
+* here (the writer's `findMany` does, but at the cost of routing through the
+* full validator pipeline; for a snapshot stream a plain offset scan is
+* sufficient and predictable).
+*/
+declare const exportGlobalRows: (exec: SqlCtxExec, schema: SchemaLike, args: ExportGlobalArgs) => AsyncGenerator<ExportRow, void, undefined>;
+interface ImportGlobalArgs {
+  /**
+  * Optional direct exec handle to the same D1 database the writer targets.
+  * When supplied, the conflict pre-probe issues a single
+  * `SELECT 1 FROM &lt;table> WHERE id = ? LIMIT 1` against the row's declared
+  * table instead of falling back to `writer.get(id)`, which scans every
+  * global table looking for the id. Strongly recommended for large schemas
+  * — the writer-fallback is O(N tables) per row.
+  */
+  exec?: D1ExecLike;
+  rows: ReadonlyArray<ExportRow>;
+  startLine?: number;
+}
+/** Minimal slice of `D1Exec` (declared locally to avoid a circular import). */
+interface D1ExecLike {
+  all: (sql: string, parameters: ReadonlyArray<unknown>) => Promise<Record<string, unknown>[]>;
+}
+/**
+* Import rows into `.global()` tables via the schema-aware D1 writer. The
+* writer rejects unknown ids on `insert` (the writer assigns one when `_id` is
+* absent); we pre-probe each row's `_id` so a collision is reported as a
+* conflict instead of bubbled as a UNIQUE error. Schema-failed rows surface in
+* `errors`; the rest land.
+*/
+declare const importGlobalRows: (writer: DatabaseWriterLike, schema: SchemaLike, args: ImportGlobalArgs) => Promise<ImportResult>;
+/**
+* Minimal structural projection of `D1Database` to keep the adapter
+* compatible with the real workers-types value as well as unit-test doubles.
+*/
+interface D1DatabaseLike {
+  batch?: (statements: D1PreparedStatementLike[]) => Promise<unknown[]>;
+  exec?: (sql: string) => Promise<unknown>;
+  prepare: (sql: string) => D1PreparedStatementLike;
+  withSession: (bookmark?: string) => D1SessionLike;
+}
+interface D1SessionLike {
+  batch?: (statements: D1PreparedStatementLike[]) => Promise<unknown[]>;
+  getBookmark: () => string | null;
+  prepare: (sql: string) => D1PreparedStatementLike;
+}
+interface D1PreparedStatementLike {
+  all: <T = unknown>() => Promise<{
+    results: T[];
+    success: boolean;
+  }>;
+  bind: (...values: unknown[]) => D1PreparedStatementLike;
+  first: <T = unknown>(column?: string) => Promise<T | null>;
+  raw: <T = unknown>() => Promise<T[][]>;
+  run: <T = unknown>() => Promise<{
+    meta?: Record<string, unknown>;
+    results?: T[];
+    success: boolean;
+  }>;
+}
+/** Thin wrapper over a `D1DatabaseSession` exposing bookmark plumbing. */
+declare class D1Session {
+  private readonly session;
+  /** See {@link D1Client.stmtCache}. Scoped per session. */
+  private readonly stmtCache;
+  constructor(session: D1SessionLike);
+  prepare(sql: string): D1PreparedStatementLike;
+  run<T = unknown>(sql: string, ...binds: unknown[]): Promise<{
+    meta?: Record<string, unknown>;
+    results?: T[];
+    success: boolean;
+  }>;
+  all<T = unknown>(sql: string, ...binds: unknown[]): Promise<{
+    results: T[];
+    success: boolean;
+  }>;
+  first<T = unknown>(sql: string, ...binds: unknown[]): Promise<T | null>;
+  /**
+  * Returns the most recent bookmark known to the session, or `undefined`
+  * when D1 has not issued one yet.
+  */
+  getBookmark(): string | undefined;
+}
+declare class D1Client {
+  private readonly db;
+  /**
+  * SQL string -> prepared statement. Prepared statements are reusable in
+  * D1; preparing the same SQL twice forces the worker to round-trip the
+  * statement plan. Caching is per-instance so unit-test isolation holds.
+  * Bounded to {@link STMT_CACHE_CAPACITY} via LRU eviction.
+  */
+  private readonly stmtCache;
+  /**
+  * Lazily-built drizzle handle over the bare binding. Memoised so a single
+  * `D1Client` reuses the same dialect/session machinery across calls.
+  */
+  private drizzleHandle;
+  constructor(database: D1DatabaseLike);
+  /**
+  * Open a Sessions-API scoped session. Pass the bookmark forwarded by
+  * the client to opt into read-your-writes consistency.
+  *
+  * With no bookmark this is the first request of a session — there is no
+  * prior write to read, so we open with the explicit `"first-unconstrained"`
+  * constraint (Cloudflare's lowest-latency default: the first read may serve
+  * from any replica). Read-your-writes for sequenced requests still flows
+  * through the forwarded bookmark; a caller needing a strongly-consistent
+  * very-first read should pass `"first-primary"` as the bookmark instead.
+  */
+  withSession(bookmark?: string): D1Session;
+  /**
+  * Prepare a statement, reusing a cached one when the SQL text matches.
+  * `bind()` on a prepared statement returns a new bound statement and
+  * leaves the underlying prepared plan reusable, so cache hits are safe
+  * even when the previous caller already called `.bind(...).run()`.
+  */
+  prepare(sql: string): D1PreparedStatementLike;
+  /**
+  * Drizzle handle over the bare `env.DB` binding. Used for typed queries
+  * against generated `sqliteTable` schemas; does **not** participate in the
+  * D1 Sessions API (no bookmark pinning). For bookmark-scoped reads, use
+  * {@link drizzleSession} instead.
+  */
+  get drizzle(): DrizzleD1Database<Record<string, unknown>>;
+  /**
+  * Drizzle handle scoped to a D1 Sessions-API session. The bookmark, when
+  * supplied, opts into read-your-writes consistency for follow-up reads on
+  * the same session.
+  *
+  * A `D1DatabaseSession` exposes the same `prepare` / `batch` surface
+  * drizzle calls into, so a single `unknown` cast lets us treat the session
+  * as a `D1Database` for driver-construction purposes.
+  */
+  drizzleSession(bookmark?: string): DrizzleD1Database<Record<string, unknown>>;
+  /**
+  * Atomic batch over the drizzle d1 driver. Mirrors `db.batch([...])`
+  * exactly; exposed on the client so callers don't need to hold a drizzle
+  * handle just to run a typed batch.
+  */
+  batch<U extends BatchItem<"sqlite">, T extends Readonly<[U, ...U[]]>>(items: T): Promise<BatchResponse<T>>;
+  /** Direct access to the underlying binding (advanced use only). */
+  get raw(): D1DatabaseLike;
+}
+/** A table plus its current row count. */
+interface GlobalTableInfo {
+  name: string;
+  rowCount: number;
+}
+/** A window of rows from one table, plus the column list and total size. */
+interface GlobalTablePage {
+  columns: string[];
+  /**
+  * Foreign-key columns (local column → referenced table) for tables that carry
+  * real SQL `REFERENCES` constraints — recovered from `PRAGMA foreign_key_list`.
+  * Schema `.global()` tables omit this (their refs come from `describeTables`);
+  * external tables (e.g. better-auth's `session`/`twoFactor`) expose it so the
+  * schema diagram can draw their global→global FK edges.
+  */
+  refs?: Record<string, string>;
+  rows: Record<string, unknown>[];
+  total: number;
+}
+/**
+* One equality constraint a facet-value click adds to the global browser's view:
+* `column = value` (or `column IS NULL` when `value` is nullish). `column` is a
+* displayed column name, validated against the table's columns and mapped to its
+* physical column (`_id` → `id`) before it is quoted; `value` is the **raw stored
+* value** the facet returned (a SQLite scalar), bound as a parameter and never
+* interpolated. AND-combined with the other clauses.
+*/
+interface GlobalFilterClause {
+  column: string;
+  value: unknown;
+}
+interface ReadGlobalTablePageOptions {
+  filters?: GlobalFilterClause[];
+  limit?: number;
+  offset?: number;
+  table: string;
+}
+/**
+* Options for {@link facetGlobalColumn} — the read-only "what values does this
+* column hold?" summary for the global (D1) browser. `column` is the displayed
+* column to group by (validated and mapped to its physical column, never
+* interpolated); `filters` mirrors {@link ReadGlobalTablePageOptions}'s eq
+* constraints so the facet reflects the **active view** (the same rows the
+* browser is previewing); `limit` caps the distinct values returned (clamped).
+*/
+interface FacetGlobalColumnOptions {
+  column: string;
+  filters?: GlobalFilterClause[];
+  limit?: number;
+  table: string;
+}
+/** One distinct value of a faceted global column with its row count over the active view. */
+interface GlobalFacetValue {
+  count: number;
+  value: unknown;
+}
+/**
+* Payload of a {@link facetGlobalColumn} call: the top-N distinct `values` (each
+* with a `count`) ordered by frequency, plus `truncated` — `true` when more
+* distinct values existed beyond the cap, so the UI can say so rather than imply
+* the list is exhaustive. Mirrors the shard browser's `FacetColumnResult`.
+*/
+interface GlobalFacetResult {
+  truncated: boolean;
+  values: GlobalFacetValue[];
+}
+/**
+* List every browsable D1 table with its row count, ordered by name. Surfaces
+* both the schema's `.global()` tables (provisioned first) and external tables
+* (auth, etc.); internal/companion tables are excluded.
+*/
+declare const listGlobalTables: (exec: SqlCtxExec, schema: SchemaLike) => Promise<GlobalTableInfo[]>;
+/**
+* Read a page of rows from one D1 table. The table is validated against the live
+* browsable-table list before its name is interpolated, so this can't be coerced
+* into reading an internal table or injecting SQL. `limit` is clamped to
+* `[1, 500]`; `offset` floors at `0`. `filters` AND-narrows the page to rows
+* matching each `column = value` eq constraint (a facet-value drill-down), bound
+* through {@link buildEqPredicate} so they never inject SQL.
+*/
+declare const readGlobalTablePage: (exec: SqlCtxExec, schema: SchemaLike, options: ReadGlobalTablePageOptions) => Promise<GlobalTablePage>;
+/**
+* Summarise the distinct values of one displayed column over the **active view**
+* (the same eq `filters` the global browser is previewing) — the D1 twin of the
+* shard browser's `facetColumn`. Read-only: a `SELECT col AS value, COUNT(*) AS
+* count … GROUP BY col ORDER BY count DESC LIMIT N+1`, with the column validated
+* against the table's displayed columns (typed 404 if unknown), mapped to its
+* physical column, and quoted — never interpolated from caller input. The extra
+* over-fetched row is dropped and surfaced as `truncated`. A sensitive column on
+* an external (non-schema) table is never grouped — it collapses to a single
+* redacted `•••` bucket — mirroring the page browser's value redaction so the
+* facet can't leak credentials. The returned `value` is the raw stored scalar, so
+* a click feeds it straight back as an eq filter.
+*/
+declare const facetGlobalColumn: (exec: SqlCtxExec, schema: SchemaLike, options: FacetGlobalColumnOptions) => Promise<GlobalFacetResult>;
+interface Migration {
+  /** Human-readable name, e.g. `001_init` (used in logs). */
+  name: string;
+  /** Raw SQL to apply. Should be idempotent where possible. */
+  sql: string;
+  /** Monotonically increasing integer used to order migrations. */
+  version: number;
+}
+interface MigrationRunnerResult {
+  applied: {
+    name: string;
+    version: number;
+  }[];
+  skipped: {
+    name: string;
+    version: number;
+  }[];
+}
+/**
+* Sequentially applies pending migrations against a D1 database via the
+* drizzle-orm/d1 driver. Each migration is hashed (SHA-256 over its SQL
+* text); the hash is stored in `__drizzle_migrations`, so re-applying the
+* same SQL under a different `version` is rejected and identical migrations
+* are skipped idempotently.
+*/
+declare class MigrationRunner {
+  private readonly client;
+  private readonly migrations;
+  /**
+  * Accepts either a {@link D1Client} (preferred — gets typed batches +
+  * drizzle handle for free) or a raw `D1DatabaseLike` binding (wrapped on
+  * the caller's behalf so existing `@lunora/cli` callers keep working).
+  */
+  constructor(database: D1Client | D1DatabaseLike, migrations: Migration[]);
+  run(): Promise<MigrationRunnerResult>;
+  private applyOne;
+  private assertUniqueVersions;
+  private assertUniqueSql;
+}
+/**
+* The canonical SQLite dialect: column affinities, the shared SQLite value
+* codec, `RETURNING` support (both D1 and `node:sqlite`), and `sqlite_master`
+* table probing. The rest of the per-statement shaping is drizzle's.
+*/
+declare const sqliteDialect: SqlDialect;
+export { D1Client, type D1ContextDatabaseOptions as D1CtxDbOptions, type D1DatabaseLike, type D1PreparedStatementLike, D1Session, type D1SessionLike, type ExportGlobalArgs, type FacetGlobalColumnOptions, type ExportRow as GlobalExportRow, type GlobalFacetResult, type GlobalFacetValue, type GlobalFilterClause, type ImportError as GlobalImportError, type ImportResult as GlobalImportResult, type GlobalTableInfo, type GlobalTablePage, type ImportGlobalArgs, type Migration, MigrationRunner, type MigrationRunnerResult, type ReadGlobalTablePageOptions, createD1ContextDatabase as createD1CtxDb, exportGlobalRows, facetGlobalColumn, importGlobalRows, listGlobalTables, readD1CdcChanges, readGlobalTablePage, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, selectGlobalTables, sqliteDialect, trimD1CdcChanges };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+export { exportGlobalRows, importGlobalRows, selectGlobalTables } from './packem_shared/exportGlobalRows-BGCPm_nA.mjs';
+export { D1Client, D1Session } from './packem_shared/D1Client-DA3flo1o.mjs';
+export { createD1CtxDb, readD1CdcChanges, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, trimD1CdcChanges } from './packem_shared/createD1CtxDb-BMR8J0dT.mjs';
+export { facetGlobalColumn, listGlobalTables, readGlobalTablePage } from './packem_shared/facetGlobalColumn-C6u_WMIY.mjs';
+export { MigrationRunner } from './packem_shared/MigrationRunner-BkEwQ-Ya.mjs';
+export { default as sqliteDialect } from './packem_shared/sqliteDialect-DqYnHPuu.mjs';
+export { createSqlCtxDb } from '@lunora/sql-store';

package/dist/packem_shared/D1Client-DA3flo1o.mjs

@@ -0,0 +1,143 @@
+import { drizzle } from 'drizzle-orm/d1';
+
+const STMT_CACHE_CAPACITY = 256;
+const D1_FIRST_UNCONSTRAINED = "first-unconstrained";
+class D1Session {
+  session;
+  /** See {@link D1Client.stmtCache}. Scoped per session. */
+  stmtCache = /* @__PURE__ */ new Map();
+  constructor(session) {
+    this.session = session;
+  }
+  prepare(sql) {
+    const cached = this.stmtCache.get(sql);
+    if (cached) {
+      this.stmtCache.delete(sql);
+      this.stmtCache.set(sql, cached);
+      return cached;
+    }
+    const stmt = this.session.prepare(sql);
+    if (this.stmtCache.size >= STMT_CACHE_CAPACITY) {
+      const oldest = this.stmtCache.keys().next().value;
+      if (oldest !== void 0) {
+        this.stmtCache.delete(oldest);
+      }
+    }
+    this.stmtCache.set(sql, stmt);
+    return stmt;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T types the result rows for the caller and is forwarded to the prepared statement.
+  async run(sql, ...binds) {
+    return this.prepare(sql).bind(...binds).run();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T types the result rows for the caller and is forwarded to the prepared statement.
+  async all(sql, ...binds) {
+    return this.prepare(sql).bind(...binds).all();
+  }
+  async first(sql, ...binds) {
+    return this.prepare(sql).bind(...binds).first();
+  }
+  /**
+   * Returns the most recent bookmark known to the session, or `undefined`
+   * when D1 has not issued one yet.
+   */
+  getBookmark() {
+    return this.session.getBookmark() ?? void 0;
+  }
+}
+class D1Client {
+  db;
+  /**
+   * SQL string -> prepared statement. Prepared statements are reusable in
+   * D1; preparing the same SQL twice forces the worker to round-trip the
+   * statement plan. Caching is per-instance so unit-test isolation holds.
+   * Bounded to {@link STMT_CACHE_CAPACITY} via LRU eviction.
+   */
+  stmtCache = /* @__PURE__ */ new Map();
+  /**
+   * Lazily-built drizzle handle over the bare binding. Memoised so a single
+   * `D1Client` reuses the same dialect/session machinery across calls.
+   */
+  drizzleHandle;
+  constructor(database) {
+    this.db = database;
+  }
+  /**
+   * Open a Sessions-API scoped session. Pass the bookmark forwarded by
+   * the client to opt into read-your-writes consistency.
+   *
+   * With no bookmark this is the first request of a session — there is no
+   * prior write to read, so we open with the explicit `"first-unconstrained"`
+   * constraint (Cloudflare's lowest-latency default: the first read may serve
+   * from any replica). Read-your-writes for sequenced requests still flows
+   * through the forwarded bookmark; a caller needing a strongly-consistent
+   * very-first read should pass `"first-primary"` as the bookmark instead.
+   */
+  withSession(bookmark) {
+    const session = this.db.withSession(bookmark ?? D1_FIRST_UNCONSTRAINED);
+    return new D1Session(session);
+  }
+  /**
+   * Prepare a statement, reusing a cached one when the SQL text matches.
+   * `bind()` on a prepared statement returns a new bound statement and
+   * leaves the underlying prepared plan reusable, so cache hits are safe
+   * even when the previous caller already called `.bind(...).run()`.
+   */
+  prepare(sql) {
+    const cached = this.stmtCache.get(sql);
+    if (cached) {
+      this.stmtCache.delete(sql);
+      this.stmtCache.set(sql, cached);
+      return cached;
+    }
+    const stmt = this.db.prepare(sql);
+    if (this.stmtCache.size >= STMT_CACHE_CAPACITY) {
+      const oldest = this.stmtCache.keys().next().value;
+      if (oldest !== void 0) {
+        this.stmtCache.delete(oldest);
+      }
+    }
+    this.stmtCache.set(sql, stmt);
+    return stmt;
+  }
+  /**
+   * Drizzle handle over the bare `env.DB` binding. Used for typed queries
+   * against generated `sqliteTable` schemas; does **not** participate in the
+   * D1 Sessions API (no bookmark pinning). For bookmark-scoped reads, use
+   * {@link drizzleSession} instead.
+   */
+  get drizzle() {
+    if (this.drizzleHandle) {
+      return this.drizzleHandle;
+    }
+    this.drizzleHandle = drizzle(this.db, { logger: false });
+    return this.drizzleHandle;
+  }
+  /**
+   * Drizzle handle scoped to a D1 Sessions-API session. The bookmark, when
+   * supplied, opts into read-your-writes consistency for follow-up reads on
+   * the same session.
+   *
+   * A `D1DatabaseSession` exposes the same `prepare` / `batch` surface
+   * drizzle calls into, so a single `unknown` cast lets us treat the session
+   * as a `D1Database` for driver-construction purposes.
+   */
+  drizzleSession(bookmark) {
+    const session = this.db.withSession(bookmark ?? D1_FIRST_UNCONSTRAINED);
+    return drizzle(session, { logger: false });
+  }
+  /**
+   * Atomic batch over the drizzle d1 driver. Mirrors `db.batch([...])`
+   * exactly; exposed on the client so callers don't need to hold a drizzle
+   * handle just to run a typed batch.
+   */
+  async batch(items) {
+    return this.drizzle.batch(items);
+  }
+  /** Direct access to the underlying binding (advanced use only). */
+  get raw() {
+    return this.db;
+  }
+}
+
+export { D1Client, D1Session };

package/dist/packem_shared/MigrationRunner-BkEwQ-Ya.mjs

@@ -0,0 +1,149 @@
+import { sql } from 'drizzle-orm';
+import { D1Client } from './D1Client-DA3flo1o.mjs';
+
+const TRACKING_TABLE_NAME = "__drizzle_migrations";
+const TRACKING_TABLE_DDL = `CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE_NAME} (id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL, created_at NUMERIC)`;
+const WHITESPACE_RE = /\s/u;
+const TRAILING_SEMICOLON_RE = /;\s*$/u;
+const SHA256_HEX_RE = /^[0-9a-f]{64}$/u;
+const assertSingleStatement = (migration) => {
+  const text = migration.sql;
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let seenStatement = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (inLineComment) {
+      if (character === "\n") {
+        inLineComment = false;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (character === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inSingle) {
+      if (character === "'") {
+        if (next === "'") {
+          index += 1;
+        } else {
+          inSingle = false;
+        }
+      }
+      continue;
+    }
+    if (inDouble) {
+      if (character === '"') {
+        if (next === '"') {
+          index += 1;
+        } else {
+          inDouble = false;
+        }
+      }
+      continue;
+    }
+    if (character === "'") {
+      inSingle = true;
+      continue;
+    }
+    if (character === '"') {
+      inDouble = true;
+      continue;
+    }
+    if (character === "-" && next === "-") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (character === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    if (character === ";") {
+      seenStatement = true;
+      continue;
+    }
+    if (seenStatement && character !== void 0 && !WHITESPACE_RE.test(character)) {
+      throw new Error(
+        `Migration "${migration.name}" (v${String(migration.version)}) contains more than one SQL statement. Split it into separate migrations — batch() runs them atomically.`
+      );
+    }
+  }
+};
+const hashMigration = async (text) => {
+  const bytes = new TextEncoder().encode(text);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+class MigrationRunner {
+  client;
+  migrations;
+  /**
+   * Accepts either a {@link D1Client} (preferred — gets typed batches +
+   * drizzle handle for free) or a raw `D1DatabaseLike` binding (wrapped on
+   * the caller's behalf so existing `@lunora/cli` callers keep working).
+   */
+  constructor(database, migrations) {
+    this.client = database instanceof D1Client ? database : new D1Client(database);
+    this.migrations = [...migrations].toSorted((a, b) => a.version - b.version);
+    this.assertUniqueVersions();
+    this.assertUniqueSql();
+  }
+  async run() {
+    await this.client.drizzle.run(sql.raw(TRACKING_TABLE_DDL));
+    const appliedRows = await this.client.drizzle.all(sql.raw(`SELECT hash FROM ${TRACKING_TABLE_NAME}`));
+    const appliedHashes = new Set(appliedRows.map((row) => row.hash));
+    const applied = [];
+    const skipped = [];
+    const hashes = await Promise.all(this.migrations.map(async (migration) => hashMigration(migration.sql)));
+    for (const [index, migration] of this.migrations.entries()) {
+      const hash = hashes[index];
+      if (appliedHashes.has(hash)) {
+        skipped.push({ name: migration.name, version: migration.version });
+        continue;
+      }
+      await this.applyOne(migration, hash);
+      applied.push({ name: migration.name, version: migration.version });
+    }
+    return { applied, skipped };
+  }
+  async applyOne(migration, hash) {
+    assertSingleStatement(migration);
+    const statementText = migration.sql.replace(TRAILING_SEMICOLON_RE, "").trim();
+    if (!SHA256_HEX_RE.test(hash)) {
+      throw new Error(`migration "${migration.name}" produced a non-hex hash; refusing to inline into SQL`);
+    }
+    const trackingInsertSql = `INSERT INTO ${TRACKING_TABLE_NAME} (hash, created_at) VALUES ('${hash}', ${String(Date.now())})`;
+    const items = [this.client.drizzle.run(sql.raw(statementText)), this.client.drizzle.run(sql.raw(trackingInsertSql))];
+    await this.client.batch(items);
+  }
+  assertUniqueVersions() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const m of this.migrations) {
+      if (seen.has(m.version)) {
+        throw new Error(`Duplicate migration version ${String(m.version)}`);
+      }
+      seen.add(m.version);
+    }
+  }
+  assertUniqueSql() {
+    const seen = /* @__PURE__ */ new Map();
+    for (const m of this.migrations) {
+      const previousVersion = seen.get(m.sql);
+      if (previousVersion !== void 0) {
+        throw new Error(`Migrations ${String(previousVersion)} and ${String(m.version)} have identical SQL — bump the content, not just the version.`);
+      }
+      seen.set(m.sql, m.version);
+    }
+  }
+}
+
+export { MigrationRunner };

package/dist/packem_shared/createD1CtxDb-BMR8J0dT.mjs

@@ -0,0 +1,14 @@
+import { createSqlCtxDb, readSqlCdcChanges, runSqlAggregateMigrations, runSqlCdcMigration, runSqlGlobalTableMigrations, runSqlRankMigrations, runSqlSearchMigrations, trimSqlCdcChanges } from '@lunora/sql-store';
+export { createSqlCtxDb, decodeGlobalRow } from '@lunora/sql-store';
+import sqliteDialect from './sqliteDialect-DqYnHPuu.mjs';
+
+const createD1ContextDatabase = (options) => createSqlCtxDb({ ...options, dialect: sqliteDialect });
+const runD1GlobalTableMigrations = (exec, schema) => runSqlGlobalTableMigrations(exec, schema, sqliteDialect);
+const runD1AggregateMigrations = (exec, schema) => runSqlAggregateMigrations(exec, schema, sqliteDialect);
+const runD1RankMigrations = (exec, schema) => runSqlRankMigrations(exec, schema, sqliteDialect);
+const runD1SearchMigrations = (exec, schema) => runSqlSearchMigrations(exec, schema, sqliteDialect);
+const runD1CdcMigration = (exec) => runSqlCdcMigration(exec, sqliteDialect);
+const readD1CdcChanges = (exec, options = {}) => readSqlCdcChanges(exec, options, sqliteDialect);
+const trimD1CdcChanges = (exec, throughSeq) => trimSqlCdcChanges(exec, throughSeq, sqliteDialect);
+
+export { createD1ContextDatabase as createD1CtxDb, readD1CdcChanges, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, trimD1CdcChanges };