@lunora/d1 1.0.0-alpha.6 → 1.0.0-alpha.60

package/LICENSE.md

@@ -103,3 +103,9 @@ Unless required by applicable law or agreed to in writing, software distributed
 under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 CONDITIONS OF ANY KIND, either express or implied. See the License for the
 specific language governing permissions and limitations under the License.
+
+<!-- DEPENDENCIES -->
+<!-- /DEPENDENCIES -->
+
+<!-- TYPE_DEPENDENCIES -->
+<!-- /TYPE_DEPENDENCIES -->

package/dist/dialect.d.mts

@@ -1,38 +1,40 @@
 /**
-* The Lunora **D1 dialect** — the single source of truth for how `.global()`
-* tables are physically shaped in D1.
-*
-* Both the runtime (`runD1GlobalTableMigrations` in `d1-ctx-db.ts`, which
-* auto-provisions tables) and the `lunora migrate generate` SQL emitter
-* (`@lunora/cli`'s `migration-diff.ts`) derive their DDL from these helpers, so
-* the table a migration writes is byte-identical to the one the runtime creates.
-* Previously each encoded the dialect independently and a comment begged them to
-* stay "in lockstep"; this module makes the lockstep structural.
-*
-* Exposed as the `@lunora/d1/dialect` subpath. Pure — no runtime dependencies —
-* so the CLI can import it without pulling the D1 runtime.
-*/
+ * Canonical SQL identifier quoter shared by `@lunora/d1` and `@lunora/do`.
+ *
+ * Double-quotes a SQL identifier and escapes any embedded double quotes by
+ * doubling them (`"` → `""`) — the ANSI/SQLite/Postgres rule. This is a
+ * security-relevant primitive (it is the sole defense against identifier
+ * injection wherever a table/column name is spliced into raw SQL), so it must
+ * have exactly ONE definition rather than byte-identical copies that can drift.
+ *
+ * Like `shared/stable-key.ts`, it is deliberately **not** a package: `@lunora/d1`
+ * and `@lunora/do` sit on the same tier with no lower-level package to host it,
+ * so each imports this file by relative path and the bundler (packem/rollup)
+ * inlines it — no runtime dependency edge, duplicated only in emitted output.
+ * Keep it genuinely zero-dependency (relative/built-in imports only) or inlining
+ * breaks. Consumers must drop `outDir`/`rootDir` from their `tsconfig.json` (a
+ * set `rootDir` raises TS6059 for this out-of-package file under `tsc --noEmit`).
+ */
+declare const quoteIdentifier: (name: string) => string;
 /** SQLite column type affinities Lunora emits. */
 type SqlAffinity = "BLOB" | "INTEGER" | "REAL" | "TEXT";
-/** Double-quote (and escape) a SQL identifier. */
-declare const quoteIdentifier: (name: string) => string;
 /**
-* SQLite affinity for a column by its validator `kind`, chosen so the value the
-* D1 layer serializes round-trips intact:
-* - `boolean` → INTEGER (stored as 1/0)
-* - `number`/`timestamp`/`date` → REAL (numeric, never coerced to text)
-* - `bytes` → BLOB
-* - everything else → TEXT — string/id/literal, `bigint` (serialized as a
-* decimal string), and object/array/record/union/any (JSON). A numeric affinity
-* would coerce a numeric-looking string and corrupt the decode.
-*/
+ * SQLite affinity for a column by its validator `kind`, chosen so the value the
+ * D1 layer serializes round-trips intact:
+ * - `boolean` → INTEGER (stored as 1/0)
+ * - `number`/`timestamp`/`date` → REAL (numeric, never coerced to text)
+ * - `bytes` → BLOB
+ * - everything else → TEXT — string/id/literal, `bigint` (serialized as a
+ * decimal string), and object/array/record/union/any (JSON). A numeric affinity
+ * would coerce a numeric-looking string and corrupt the decode.
+ */
 declare const sqlAffinityForKind: (kind: string | undefined) => SqlAffinity;
 /** Framework columns every global table carries: the physical `id` (exposed as `_id`) and `_creationTime`. */
 declare const frameworkColumnDdl: () => ReadonlyArray<string>;
 /**
-* Resolve a schema field to its physical D1 column: `_id`/`id` both map to the
-* physical `id` column, `_creationTime` to its own, every other field to itself.
-*/
+ * Resolve a schema field to its physical D1 column: `_id`/`id` both map to the
+ * physical `id` column, `_creationTime` to its own, every other field to itself.
+ */
 declare const columnRef: (field: string) => string;
 /** Physical index identifier — `&lt;table>_&lt;name>`, so two tables' like-named indexes don't collide in SQLite's flat index namespace. */
 declare const physicalIndexName: (tableName: string, indexName: string) => string;

package/dist/dialect.d.ts

@@ -1,38 +1,40 @@
 /**
-* The Lunora **D1 dialect** — the single source of truth for how `.global()`
-* tables are physically shaped in D1.
-*
-* Both the runtime (`runD1GlobalTableMigrations` in `d1-ctx-db.ts`, which
-* auto-provisions tables) and the `lunora migrate generate` SQL emitter
-* (`@lunora/cli`'s `migration-diff.ts`) derive their DDL from these helpers, so
-* the table a migration writes is byte-identical to the one the runtime creates.
-* Previously each encoded the dialect independently and a comment begged them to
-* stay "in lockstep"; this module makes the lockstep structural.
-*
-* Exposed as the `@lunora/d1/dialect` subpath. Pure — no runtime dependencies —
-* so the CLI can import it without pulling the D1 runtime.
-*/
+ * Canonical SQL identifier quoter shared by `@lunora/d1` and `@lunora/do`.
+ *
+ * Double-quotes a SQL identifier and escapes any embedded double quotes by
+ * doubling them (`"` → `""`) — the ANSI/SQLite/Postgres rule. This is a
+ * security-relevant primitive (it is the sole defense against identifier
+ * injection wherever a table/column name is spliced into raw SQL), so it must
+ * have exactly ONE definition rather than byte-identical copies that can drift.
+ *
+ * Like `shared/stable-key.ts`, it is deliberately **not** a package: `@lunora/d1`
+ * and `@lunora/do` sit on the same tier with no lower-level package to host it,
+ * so each imports this file by relative path and the bundler (packem/rollup)
+ * inlines it — no runtime dependency edge, duplicated only in emitted output.
+ * Keep it genuinely zero-dependency (relative/built-in imports only) or inlining
+ * breaks. Consumers must drop `outDir`/`rootDir` from their `tsconfig.json` (a
+ * set `rootDir` raises TS6059 for this out-of-package file under `tsc --noEmit`).
+ */
+declare const quoteIdentifier: (name: string) => string;
 /** SQLite column type affinities Lunora emits. */
 type SqlAffinity = "BLOB" | "INTEGER" | "REAL" | "TEXT";
-/** Double-quote (and escape) a SQL identifier. */
-declare const quoteIdentifier: (name: string) => string;
 /**
-* SQLite affinity for a column by its validator `kind`, chosen so the value the
-* D1 layer serializes round-trips intact:
-* - `boolean` → INTEGER (stored as 1/0)
-* - `number`/`timestamp`/`date` → REAL (numeric, never coerced to text)
-* - `bytes` → BLOB
-* - everything else → TEXT — string/id/literal, `bigint` (serialized as a
-* decimal string), and object/array/record/union/any (JSON). A numeric affinity
-* would coerce a numeric-looking string and corrupt the decode.
-*/
+ * SQLite affinity for a column by its validator `kind`, chosen so the value the
+ * D1 layer serializes round-trips intact:
+ * - `boolean` → INTEGER (stored as 1/0)
+ * - `number`/`timestamp`/`date` → REAL (numeric, never coerced to text)
+ * - `bytes` → BLOB
+ * - everything else → TEXT — string/id/literal, `bigint` (serialized as a
+ * decimal string), and object/array/record/union/any (JSON). A numeric affinity
+ * would coerce a numeric-looking string and corrupt the decode.
+ */
 declare const sqlAffinityForKind: (kind: string | undefined) => SqlAffinity;
 /** Framework columns every global table carries: the physical `id` (exposed as `_id`) and `_creationTime`. */
 declare const frameworkColumnDdl: () => ReadonlyArray<string>;
 /**
-* Resolve a schema field to its physical D1 column: `_id`/`id` both map to the
-* physical `id` column, `_creationTime` to its own, every other field to itself.
-*/
+ * Resolve a schema field to its physical D1 column: `_id`/`id` both map to the
+ * physical `id` column, `_creationTime` to its own, every other field to itself.
+ */
 declare const columnRef: (field: string) => string;
 /** Physical index identifier — `&lt;table>_&lt;name>`, so two tables' like-named indexes don't collide in SQLite's flat index namespace. */
 declare const physicalIndexName: (tableName: string, indexName: string) => string;

package/dist/dialect.mjs

@@ -1,35 +1 @@
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
-const sqlAffinityForKind = (kind) => {
-  switch (kind) {
-    case "boolean": {
-      return "INTEGER";
-    }
-    case "bytes": {
-      return "BLOB";
-    }
-    case "date":
-    case "number":
-    case "timestamp": {
-      return "REAL";
-    }
-    default: {
-      return "TEXT";
-    }
-  }
-};
-const frameworkColumnDdl = () => [
-  `${quoteIdentifier("id")} TEXT PRIMARY KEY`,
-  `${quoteIdentifier("_creationTime")} REAL NOT NULL`
-];
-const columnRef = (field) => {
-  if (field === "_id" || field === "id") {
-    return quoteIdentifier("id");
-  }
-  if (field === "_creationTime") {
-    return quoteIdentifier("_creationTime");
-  }
-  return quoteIdentifier(field);
-};
-const physicalIndexName = (tableName, indexName) => quoteIdentifier(`${tableName}_${indexName}`);
-
-export { columnRef, frameworkColumnDdl, physicalIndexName, quoteIdentifier, sqlAffinityForKind };
+import{quoteIdentifier as i}from"./packem_shared/quoteIdentifier-CObIFRhb.mjs";const t=e=>{switch(e){case"boolean":return"INTEGER";case"bytes":return"BLOB";case"date":case"number":case"timestamp":return"REAL";default:return"TEXT"}},a=()=>[`${i("id")} TEXT PRIMARY KEY`,`${i("_creationTime")} REAL NOT NULL`],o=e=>e==="_id"||e==="id"?i("id"):e==="_creationTime"?i("_creationTime"):i(e),c=(e,r)=>i(`${e}_${r}`);export{o as columnRef,a as frameworkColumnDdl,c as physicalIndexName,i as quoteIdentifier,t as sqlAffinityForKind};

package/dist/index.d.mts

@@ -1,6 +1,8 @@
-import { SchemaLike, DatabaseWriterLike } from '@lunora/do';
-import { SqlCtxDbOptions, createSqlCtxDb, SqlCtxExec, readSqlCdcChanges, SqlDialect } from '@lunora/sql-store';
+import { SchemaLike, DatabaseWriterLike } from '@lunora/shard-engine';
+import { SqlCtxDbOptions, SqlCtxExec, createSqlCtxDb, readSqlCdcChanges, SqlDialect } from '@lunora/sql-store';
 export { type SqlCtxExec as D1Exec, type SqlCtxDbOptions, type SqlCtxExec, createSqlCtxDb } from '@lunora/sql-store';
+import { D1DatabaseLike, D1SessionLike, D1PreparedStatementLike } from '@lunora/platform';
+export type { D1DatabaseLike, D1PreparedStatementLike, D1SessionLike } from '@lunora/platform';
 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). */
@@ -13,8 +15,10 @@ declare const runD1GlobalTableMigrations: (exec: SqlCtxExec, schema: SchemaLike)
 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). */
+/** Materialize (and backfill) the `__fts_&lt;index>` fts5 shadow tables for the schema's search indexes. */
 declare const runD1SearchMigrations: (exec: SqlCtxExec, schema: SchemaLike) => Promise<void>;
+/** Index existing rows into every search companion, including the `staged: true` ones migrations leave empty. */
+declare const backfillD1SearchIndexes: (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. */
@@ -27,6 +31,17 @@ declare const trimD1CdcChanges: (exec: SqlCtxExec, throughSeq: number) => Promis
 /** One exported row: `doc` is reconstructed from the column tuple. */
 interface ExportRow {
   doc: Record<string, unknown>;
+  /**
+   * True physical source line, when the caller has it (e.g. a global row
+   * pulled out of an interspersed NDJSON import stream by
+   * `@lunora/runtime`'s `import-stream.ts`). When present this overrides the
+   * position-derived line below — the caller-side positions of a
+   * global-only subset don't line up with the original file once
+   * non-global rows have been filtered out. Absent for callers with no
+   * physical source to attribute (e.g. a fresh `exportGlobalRows` roundtrip
+   * in tests), which keeps the positional fallback.
+   */
+  line?: number;
   table: string;
 }
 interface ImportError {
@@ -42,32 +57,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,42 +102,13 @@ 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.
-*/
-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;
@@ -131,67 +127,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 hand the session to
+   * the driver.
+   */
   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 +201,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 +230,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 +249,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 +306,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 +327,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 };
+export { D1Client, type D1ContextDatabaseOptions as D1CtxDbOptions, D1Session, 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, backfillD1SearchIndexes, createD1ContextDatabase as createD1CtxDb, exportGlobalRows, facetGlobalColumn, importGlobalRows, listGlobalTables, readD1CdcChanges, readGlobalTablePage, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, selectGlobalTables, sqliteDialect, trimD1CdcChanges };