@lunora/d1 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/index.d.ts

@@ -42,32 +42,42 @@ interface ImportResult {
   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.
-*/
+ * 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).
-*/
+ * Yield rows from every requested `.global()` table in batches.
+ *
+ * Keyset-paginates on the physical primary key (`id` — every `.global()` table
+ * carries it, see `frameworkColumnDdl`): `WHERE "id" > ? ORDER BY "id" LIMIT ?`,
+ * carrying the last id forward. A plain `LIMIT/OFFSET` scan would be wrong here —
+ * SQLite gives no ordering guarantee for an unordered SELECT and each page is a
+ * separate query, so pages could overlap or skip rows (and any concurrent
+ * insert/delete would shift offsets and silently drop/duplicate rows in the
+ * snapshot). Keyset paging is deterministic under concurrent writes and avoids
+ * O(n^2) OFFSET scans on large tables.
+ *
+ * Tables are provisioned first (idempotent `CREATE … IF NOT EXISTS`): `.global()`
+ * tables are created lazily on first write, so a fresh deployment — or any table
+ * never written — would otherwise abort the stream with a raw `no such table`
+ * instead of exporting it as empty.
+ */
 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.
-  */
+   * 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;
@@ -77,20 +87,19 @@ 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.
-*/
+ * 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.
-*/
+ * 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;
 }
@@ -131,67 +140,67 @@ declare class D1Session {
   }>;
   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.
-  */
+   * 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.
-  */
+   * 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.
-  */
+   * 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.
-  */
+   * 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 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.
-  */
+   * 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.
-  */
+   * 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.
-  */
+   * 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;
@@ -205,24 +214,24 @@ interface GlobalTableInfo {
 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.
-  */
+   * 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.
-*/
+ * 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;
@@ -234,13 +243,13 @@ interface ReadGlobalTablePageOptions {
   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).
-*/
+ * 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[];
@@ -253,43 +262,43 @@ interface GlobalFacetValue {
   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`.
-*/
+ * 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.
-*/
+ * 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.
-*/
+ * 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.
-*/
+ * 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). */
@@ -310,20 +319,20 @@ interface MigrationRunnerResult {
   }[];
 }
 /**
-* 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.
-*/
+ * 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).
-  */
+   * 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;
@@ -331,9 +340,9 @@ declare class MigrationRunner {
   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.
-*/
+ * 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

@@ -1,7 +1,7 @@
-export { exportGlobalRows, importGlobalRows, selectGlobalTables } from './packem_shared/exportGlobalRows-BGCPm_nA.mjs';
-export { D1Client, D1Session } from './packem_shared/D1Client-DA3flo1o.mjs';
+export { exportGlobalRows, importGlobalRows, selectGlobalTables } from './packem_shared/exportGlobalRows-q0RgCLPM.mjs';
+export { D1Client, D1Session } from './packem_shared/D1Client-DSj8p7c4.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 { facetGlobalColumn, listGlobalTables, readGlobalTablePage } from './packem_shared/facetGlobalColumn-DnglIe4P.mjs';
+export { MigrationRunner } from './packem_shared/MigrationRunner-A-o1LTKj.mjs';
 export { default as sqliteDialect } from './packem_shared/sqliteDialect-DqYnHPuu.mjs';
 export { createSqlCtxDb } from '@lunora/sql-store';

package/dist/packem_shared/{D1Client-DA3flo1o.mjs → D1Client-DSj8p7c4.mjs}

@@ -1,6 +1,28 @@
 import { drizzle } from 'drizzle-orm/d1';
 
+const evictOldestEntry = (map, capacity) => {
+  if (map.size < capacity) {
+    return;
+  }
+  const oldest = map.keys().next().value;
+  if (oldest !== void 0) {
+    map.delete(oldest);
+  }
+};
+
 const STMT_CACHE_CAPACITY = 256;
+const prepareCached = (cache, prepare, sql) => {
+  const cached = cache.get(sql);
+  if (cached) {
+    cache.delete(sql);
+    cache.set(sql, cached);
+    return cached;
+  }
+  const stmt = prepare(sql);
+  evictOldestEntry(cache, STMT_CACHE_CAPACITY);
+  cache.set(sql, stmt);
+  return stmt;
+};
 const D1_FIRST_UNCONSTRAINED = "first-unconstrained";
 class D1Session {
   session;
@@ -10,21 +32,7 @@ class D1Session {
     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;
+    return prepareCached(this.stmtCache, (text) => this.session.prepare(text), sql);
   }
   // 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) {
@@ -84,21 +92,7 @@ class D1Client {
    * 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;
+    return prepareCached(this.stmtCache, (text) => this.db.prepare(text), sql);
   }
   /**
    * Drizzle handle over the bare `env.DB` binding. Used for typed queries

package/dist/packem_shared/{MigrationRunner-BkEwQ-Ya.mjs → MigrationRunner-A-o1LTKj.mjs}

@@ -1,18 +1,19 @@
+import { LunoraError } from '@lunora/errors';
 import { sql } from 'drizzle-orm';
-import { D1Client } from './D1Client-DA3flo1o.mjs';
+import { D1Client } from './D1Client-DSj8p7c4.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 TRACKING_TABLE_DDL = `CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE_NAME} (id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL UNIQUE, created_at NUMERIC)`;
 const WHITESPACE_RE = /\s/u;
-const TRAILING_SEMICOLON_RE = /;\s*$/u;
 const SHA256_HEX_RE = /^[0-9a-f]{64}$/u;
+const TRACKING_HASH_UNIQUE_RE = new RegExp(String.raw`UNIQUE constraint failed:\s*${TRACKING_TABLE_NAME}\.hash`, "iu");
 const assertSingleStatement = (migration) => {
   const text = migration.sql;
   let inSingle = false;
   let inDouble = false;
   let inLineComment = false;
   let inBlockComment = false;
-  let seenStatement = false;
+  let terminatorIndex;
   for (let index = 0; index < text.length; index += 1) {
     const character = text[index];
     const next = text[index + 1];
@@ -49,14 +50,6 @@ const assertSingleStatement = (migration) => {
       }
       continue;
     }
-    if (character === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (character === '"') {
-      inDouble = true;
-      continue;
-    }
     if (character === "-" && next === "-") {
       inLineComment = true;
       index += 1;
@@ -67,16 +60,28 @@ const assertSingleStatement = (migration) => {
       index += 1;
       continue;
     }
-    if (character === ";") {
-      seenStatement = true;
+    if (terminatorIndex !== void 0) {
+      if (character !== void 0 && !WHITESPACE_RE.test(character)) {
+        throw new LunoraError(
+          "INTERNAL",
+          `Migration "${migration.name}" (v${String(migration.version)}) contains more than one SQL statement. Split it into separate migrations — batch() runs them atomically.`
+        );
+      }
       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.`
-      );
+    if (character === "'") {
+      inSingle = true;
+      continue;
+    }
+    if (character === '"') {
+      inDouble = true;
+      continue;
+    }
+    if (character === ";") {
+      terminatorIndex = index;
     }
   }
+  return terminatorIndex;
 };
 const hashMigration = async (text) => {
   const bytes = new TextEncoder().encode(text);
@@ -110,26 +115,38 @@ class MigrationRunner {
         skipped.push({ name: migration.name, version: migration.version });
         continue;
       }
-      await this.applyOne(migration, hash);
-      applied.push({ name: migration.name, version: migration.version });
+      const didApply = await this.applyOne(migration, hash);
+      if (didApply) {
+        applied.push({ name: migration.name, version: migration.version });
+      } else {
+        skipped.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();
+    const terminatorIndex = assertSingleStatement(migration);
+    const statementText = (terminatorIndex === void 0 ? migration.sql : migration.sql.slice(0, terminatorIndex)).trim();
     if (!SHA256_HEX_RE.test(hash)) {
-      throw new Error(`migration "${migration.name}" produced a non-hex hash; refusing to inline into SQL`);
+      throw new LunoraError("INTERNAL", `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);
+    try {
+      await this.client.batch(items);
+    } catch (error) {
+      if (TRACKING_HASH_UNIQUE_RE.test(error instanceof Error ? error.message : String(error))) {
+        return false;
+      }
+      throw error;
+    }
+    return true;
   }
   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)}`);
+        throw new LunoraError("INTERNAL", `Duplicate migration version ${String(m.version)}`);
       }
       seen.add(m.version);
     }
@@ -139,7 +156,10 @@ class MigrationRunner {
     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.`);
+        throw new LunoraError(
+          "INTERNAL",
+          `Migrations ${String(previousVersion)} and ${String(m.version)} have identical SQL — bump the content, not just the version.`
+        );
       }
       seen.set(m.sql, m.version);
     }

package/dist/packem_shared/{exportGlobalRows-BGCPm_nA.mjs → exportGlobalRows-q0RgCLPM.mjs}

@@ -1,7 +1,9 @@
+import { toErrorBody } from '@lunora/errors';
+import { runD1GlobalTableMigrations } from './createD1CtxDb-BMR8J0dT.mjs';
+import { quoteIdentifier } from './quoteIdentifier-B-ZeSe1V.mjs';
 import { decodeGlobalRow } from '@lunora/sql-store';
 
 const DEFAULT_BATCH_SIZE = 200;
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
 const selectGlobalTables = (schema, requested) => {
   const isGlobal = (table) => schema.tables[table]?.shardMode?.kind === "global";
   if (requested && requested.length > 0) {
@@ -19,16 +21,21 @@ const decodeRow = (schema, table, row) => {
 const exportGlobalRows = async function* (exec, schema, args) {
   const tables = selectGlobalTables(schema, args.tables);
   const batchSize = args.batchSize ?? DEFAULT_BATCH_SIZE;
+  await runD1GlobalTableMigrations(exec, schema);
   for (const table of tables) {
-    let offset = 0;
+    const quoted = quoteIdentifier(table);
+    let lastId;
     let hasMore = true;
     while (hasMore) {
-      const rows = await exec.all(`SELECT * FROM ${quoteIdentifier(table)} LIMIT ? OFFSET ?`, [batchSize, offset]);
+      const rows = lastId === void 0 ? await exec.all(`SELECT * FROM ${quoted} ORDER BY "id" LIMIT ?`, [batchSize]) : await exec.all(`SELECT * FROM ${quoted} WHERE "id" > ? ORDER BY "id" LIMIT ?`, [lastId, batchSize]);
       for (const row of rows) {
         yield { doc: decodeRow(schema, table, row), table };
       }
+      const last = rows.at(-1);
+      if (last !== void 0) {
+        lastId = String(last["id"]);
+      }
       hasMore = rows.length === batchSize;
-      offset += rows.length;
     }
   }
 };
@@ -88,9 +95,8 @@ const importOneRow = async (writer, schema, args, row, line) => {
     await writer.insert(table, doc, { allowExplicitId: true });
     return { inserted: table, kind: "inserted" };
   } catch (error) {
-    const code = error.code ?? "INSERT_FAILED";
-    const message = error instanceof Error ? error.message : String(error);
-    return { error: { code, line, message, table }, kind: "error" };
+    const { body } = toErrorBody(error, { fallbackCode: "INSERT_FAILED" });
+    return { error: { code: body.code, line, message: body.message, table }, kind: "error" };
   }
 };
 const importGlobalRows = async (writer, schema, args) => {