@lunora/d1 1.0.0-alpha.79 → 1.0.0-alpha.80

package/dist/index.d.mts

@@ -109,22 +109,48 @@ interface D1ExecLike {
  * `errors`; the rest land.
  */
 declare const importGlobalRows: (writer: DatabaseWriterLike, schema: SchemaLike, args: ImportGlobalArgs) => Promise<ImportResult>;
-/** Thin wrapper over a `D1DatabaseSession` exposing bookmark plumbing. */
+/**
+ * Thin wrapper over a `D1DatabaseSession` exposing bookmark plumbing.
+ *
+ * `all` and `first` retry D1's expected transient failures — but only for a
+ * statement that is provably read-only. D1 produces a documented
+ * baseline of infrastructural errors even when healthy (Cloudflare's team calls
+ * a handful every few hours "not unexpected") and their guidance is to retry;
+ * a client that does not has adopted that error rate as the application's own.
+ *
+ * Nothing else on this class or on {@link D1Client} retries. `run` is the write
+ * path, and every transient D1 error is ambiguous about whether the statement
+ * applied — re-running a non-idempotent write after a lost response
+ * double-applies it. `all` is not a read path either: D1 runs
+ * `UPDATE … RETURNING` through it, so the retry is gated on the statement's
+ * leading keyword rather than on the method name. Wrap a genuinely idempotent
+ * write in {@link withD1Retry} yourself, per call.
+ */
 declare class D1Session {
   private readonly session;
   /** See {@link D1Client.stmtCache}. Scoped per session. */
   private readonly stmtCache;
   constructor(session: D1SessionLike);
   prepare(sql: string): D1PreparedStatementLike;
+  /**
+   * Execute a statement. **Not retried** — `run` is the write path, and a
+   * transient D1 error does not say whether the write applied.
+   */
   run<T = unknown>(sql: string, ...binds: unknown[]): Promise<{
     meta?: Record<string, unknown>;
     results?: T[];
     success: boolean;
   }>;
+  /**
+   * Read all rows, retrying D1's transient failures when `sql` is a
+   * read-only statement. An `UPDATE … RETURNING` runs through here too and is
+   * left unretried.
+   */
   all<T = unknown>(sql: string, ...binds: unknown[]): Promise<{
     results: T[];
     success: boolean;
   }>;
+  /** Read the first row, retrying under the same read-only rule as {@link all}. */
   first<T = unknown>(sql: string, ...binds: unknown[]): Promise<T | null>;
   /**
    * Returns the most recent bookmark known to the session, or `undefined`
@@ -132,6 +158,16 @@ declare class D1Session {
    */
   getBookmark(): string | undefined;
 }
+/**
+ * A D1 handle: prepared-statement caching, Sessions-API sessions, and the
+ * drizzle-typed accessors.
+ *
+ * **Nothing on this class retries.** `prepare`, `drizzle`, `drizzleSession`,
+ * `batch` and `raw` all hand back the underlying D1 surface untouched. The
+ * automatic retry lives on {@link D1Session.all} / {@link D1Session.first} and
+ * on `retryingExec` (the seam `.global()` tables read through); wrap anything
+ * else in {@link withD1Retry} yourself, and only when it is safe to run twice.
+ */
 declare class D1Client {
   private readonly db;
   /**
@@ -326,10 +362,89 @@ declare class MigrationRunner {
   private assertUniqueVersions;
   private assertUniqueSql;
 }
+/** Tuning for {@link withD1Retry}. */
+interface D1RetryOptions {
+  /** Total attempts including the first. Default 3. Must be >= 1. */
+  attempts?: number;
+  /**
+   * Total budget across every attempt and backoff, in ms. An attempt still
+   * running when the budget expires is abandoned, and a backoff never sleeps
+   * past it.
+   *
+   * `timeoutMs` bounds one attempt; this bounds the operation.
+   */
+  deadlineMs?: number;
+  /** Sleep implementation. Injected so tests need no timers. */
+  sleep?: (ms: number) => Promise<void>;
+  /**
+   * Abandon a single attempt that has not settled within this many ms, and
+   * treat it as a transient failure.
+   *
+   * There is no default — a legitimate analytical query and a stalled one
+   * look identical from outside, so the value has to come from what your
+   * workload actually needs. Unset, {@link SLOW_FAILURE_MS} stops a slow
+   * failure from being retried rather than guessing a bound for you.
+   *
+   * Only ever applied to operations that are safe to abandon. It does not
+   * cancel the underlying D1 call.
+   */
+  timeoutMs?: number;
+}
+/**
+ * True when `error` looks like one of D1's expected transient failures.
+ *
+ * Deliberately conservative: an unrecognised error is treated as **permanent**
+ * and surfaces immediately. Retrying a genuine bug — a syntax error, a
+ * constraint violation — turns one fast failure into three slow ones and
+ * hides the cause.
+ * @experimental
+ */
+declare const isTransientD1Error: (error: unknown) => boolean;
+/**
+ * Thrown when an attempt is abandoned for exceeding
+ * {@link D1RetryOptions.timeoutMs}.
+ *
+ * Its own class so a caller can tell "D1 hung" apart from "D1 returned an
+ * error" — they have different remedies, and collapsing them hides which one
+ * is happening.
+ * @experimental
+ */
+declare class D1TimeoutError extends Error {
+  /** Milliseconds waited before the attempt was abandoned. */
+  readonly timeoutMs: number;
+  constructor(timeoutMs: number);
+}
+/**
+ * Run `operation`, retrying D1's transient failures with exponential backoff
+ * and jitter.
+ *
+ * **Only wrap operations that are safe to run more than once.** Reads always
+ * are. A write is only if it is idempotent — an upsert keyed on a primary key,
+ * a delete by id, an `INSERT OR IGNORE`. A bare `INSERT` or a relative
+ * `UPDATE` is not, and re-running one after a lost response double-applies it.
+ * @experimental
+ */
+declare const withD1Retry: <T>(operation: () => Promise<T>, options?: D1RetryOptions) => Promise<T>;
+/**
+ * Wrap a `.global()` exec so its **read-only** statements retry D1's transient
+ * failures.
+ *
+ * This is where the retry has to live to reach an application: `.global()`
+ * tables run every read through the exec codegen builds over the raw D1
+ * binding, not through a `D1Client`. `run` and `batch` are passed straight
+ * through — they are the write path, and a transient D1 error does not say
+ * whether the write applied.
+ *
+ * `all` is not the read path either. It only retries when
+ * {@link isReadOnlyD1Sql} proves the statement is one, because `UPDATE …
+ * RETURNING` runs through `all` too.
+ * @experimental
+ */
+declare const retryingExec: (exec: SqlCtxExec, options?: D1RetryOptions) => SqlCtxExec;
 /**
  * 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, 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 };
+export { D1Client, type D1ContextDatabaseOptions as D1CtxDbOptions, type D1RetryOptions, D1Session, D1TimeoutError, 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, isTransientD1Error, listGlobalTables, readD1CdcChanges, readGlobalTablePage, retryingExec, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, selectGlobalTables, sqliteDialect, trimD1CdcChanges, withD1Retry };

package/dist/index.d.ts

@@ -109,22 +109,48 @@ interface D1ExecLike {
  * `errors`; the rest land.
  */
 declare const importGlobalRows: (writer: DatabaseWriterLike, schema: SchemaLike, args: ImportGlobalArgs) => Promise<ImportResult>;
-/** Thin wrapper over a `D1DatabaseSession` exposing bookmark plumbing. */
+/**
+ * Thin wrapper over a `D1DatabaseSession` exposing bookmark plumbing.
+ *
+ * `all` and `first` retry D1's expected transient failures — but only for a
+ * statement that is provably read-only. D1 produces a documented
+ * baseline of infrastructural errors even when healthy (Cloudflare's team calls
+ * a handful every few hours "not unexpected") and their guidance is to retry;
+ * a client that does not has adopted that error rate as the application's own.
+ *
+ * Nothing else on this class or on {@link D1Client} retries. `run` is the write
+ * path, and every transient D1 error is ambiguous about whether the statement
+ * applied — re-running a non-idempotent write after a lost response
+ * double-applies it. `all` is not a read path either: D1 runs
+ * `UPDATE … RETURNING` through it, so the retry is gated on the statement's
+ * leading keyword rather than on the method name. Wrap a genuinely idempotent
+ * write in {@link withD1Retry} yourself, per call.
+ */
 declare class D1Session {
   private readonly session;
   /** See {@link D1Client.stmtCache}. Scoped per session. */
   private readonly stmtCache;
   constructor(session: D1SessionLike);
   prepare(sql: string): D1PreparedStatementLike;
+  /**
+   * Execute a statement. **Not retried** — `run` is the write path, and a
+   * transient D1 error does not say whether the write applied.
+   */
   run<T = unknown>(sql: string, ...binds: unknown[]): Promise<{
     meta?: Record<string, unknown>;
     results?: T[];
     success: boolean;
   }>;
+  /**
+   * Read all rows, retrying D1's transient failures when `sql` is a
+   * read-only statement. An `UPDATE … RETURNING` runs through here too and is
+   * left unretried.
+   */
   all<T = unknown>(sql: string, ...binds: unknown[]): Promise<{
     results: T[];
     success: boolean;
   }>;
+  /** Read the first row, retrying under the same read-only rule as {@link all}. */
   first<T = unknown>(sql: string, ...binds: unknown[]): Promise<T | null>;
   /**
    * Returns the most recent bookmark known to the session, or `undefined`
@@ -132,6 +158,16 @@ declare class D1Session {
    */
   getBookmark(): string | undefined;
 }
+/**
+ * A D1 handle: prepared-statement caching, Sessions-API sessions, and the
+ * drizzle-typed accessors.
+ *
+ * **Nothing on this class retries.** `prepare`, `drizzle`, `drizzleSession`,
+ * `batch` and `raw` all hand back the underlying D1 surface untouched. The
+ * automatic retry lives on {@link D1Session.all} / {@link D1Session.first} and
+ * on `retryingExec` (the seam `.global()` tables read through); wrap anything
+ * else in {@link withD1Retry} yourself, and only when it is safe to run twice.
+ */
 declare class D1Client {
   private readonly db;
   /**
@@ -326,10 +362,89 @@ declare class MigrationRunner {
   private assertUniqueVersions;
   private assertUniqueSql;
 }
+/** Tuning for {@link withD1Retry}. */
+interface D1RetryOptions {
+  /** Total attempts including the first. Default 3. Must be >= 1. */
+  attempts?: number;
+  /**
+   * Total budget across every attempt and backoff, in ms. An attempt still
+   * running when the budget expires is abandoned, and a backoff never sleeps
+   * past it.
+   *
+   * `timeoutMs` bounds one attempt; this bounds the operation.
+   */
+  deadlineMs?: number;
+  /** Sleep implementation. Injected so tests need no timers. */
+  sleep?: (ms: number) => Promise<void>;
+  /**
+   * Abandon a single attempt that has not settled within this many ms, and
+   * treat it as a transient failure.
+   *
+   * There is no default — a legitimate analytical query and a stalled one
+   * look identical from outside, so the value has to come from what your
+   * workload actually needs. Unset, {@link SLOW_FAILURE_MS} stops a slow
+   * failure from being retried rather than guessing a bound for you.
+   *
+   * Only ever applied to operations that are safe to abandon. It does not
+   * cancel the underlying D1 call.
+   */
+  timeoutMs?: number;
+}
+/**
+ * True when `error` looks like one of D1's expected transient failures.
+ *
+ * Deliberately conservative: an unrecognised error is treated as **permanent**
+ * and surfaces immediately. Retrying a genuine bug — a syntax error, a
+ * constraint violation — turns one fast failure into three slow ones and
+ * hides the cause.
+ * @experimental
+ */
+declare const isTransientD1Error: (error: unknown) => boolean;
+/**
+ * Thrown when an attempt is abandoned for exceeding
+ * {@link D1RetryOptions.timeoutMs}.
+ *
+ * Its own class so a caller can tell "D1 hung" apart from "D1 returned an
+ * error" — they have different remedies, and collapsing them hides which one
+ * is happening.
+ * @experimental
+ */
+declare class D1TimeoutError extends Error {
+  /** Milliseconds waited before the attempt was abandoned. */
+  readonly timeoutMs: number;
+  constructor(timeoutMs: number);
+}
+/**
+ * Run `operation`, retrying D1's transient failures with exponential backoff
+ * and jitter.
+ *
+ * **Only wrap operations that are safe to run more than once.** Reads always
+ * are. A write is only if it is idempotent — an upsert keyed on a primary key,
+ * a delete by id, an `INSERT OR IGNORE`. A bare `INSERT` or a relative
+ * `UPDATE` is not, and re-running one after a lost response double-applies it.
+ * @experimental
+ */
+declare const withD1Retry: <T>(operation: () => Promise<T>, options?: D1RetryOptions) => Promise<T>;
+/**
+ * Wrap a `.global()` exec so its **read-only** statements retry D1's transient
+ * failures.
+ *
+ * This is where the retry has to live to reach an application: `.global()`
+ * tables run every read through the exec codegen builds over the raw D1
+ * binding, not through a `D1Client`. `run` and `batch` are passed straight
+ * through — they are the write path, and a transient D1 error does not say
+ * whether the write applied.
+ *
+ * `all` is not the read path either. It only retries when
+ * {@link isReadOnlyD1Sql} proves the statement is one, because `UPDATE …
+ * RETURNING` runs through `all` too.
+ * @experimental
+ */
+declare const retryingExec: (exec: SqlCtxExec, options?: D1RetryOptions) => SqlCtxExec;
 /**
  * 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, 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 };
+export { D1Client, type D1ContextDatabaseOptions as D1CtxDbOptions, type D1RetryOptions, D1Session, D1TimeoutError, 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, isTransientD1Error, listGlobalTables, readD1CdcChanges, readGlobalTablePage, retryingExec, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, selectGlobalTables, sqliteDialect, trimD1CdcChanges, withD1Retry };

package/dist/index.mjs

@@ -1 +1 @@
-import{exportGlobalRows as a,importGlobalRows as o,selectGlobalTables as l}from"./packem_shared/exportGlobalRows-Cc8cXltm.mjs";import{D1Client as i,D1Session as n}from"./packem_shared/D1Client-IzEOlt9I.mjs";import{backfillD1SearchIndexes as b,createD1CtxDb as D,readD1CdcChanges as g,runD1AggregateMigrations as c,runD1CdcMigration as x,runD1GlobalTableMigrations as f,runD1RankMigrations as m,runD1SearchMigrations as p,trimD1CdcChanges as C}from"./packem_shared/backfillD1SearchIndexes-By6bbCLe.mjs";import{facetGlobalColumn as d,listGlobalTables as G,readGlobalTablePage as M}from"./packem_shared/facetGlobalColumn-D1npxpva.mjs";import{MigrationRunner as R}from"./packem_shared/MigrationRunner-IF213ALw.mjs";import{default as T}from"./packem_shared/sqliteDialect-DZoYJOa-.mjs";import{createSqlCtxDb as q}from"@lunora/sql-store";export{i as D1Client,n as D1Session,R as MigrationRunner,b as backfillD1SearchIndexes,D as createD1CtxDb,q as createSqlCtxDb,a as exportGlobalRows,d as facetGlobalColumn,o as importGlobalRows,G as listGlobalTables,g as readD1CdcChanges,M as readGlobalTablePage,c as runD1AggregateMigrations,x as runD1CdcMigration,f as runD1GlobalTableMigrations,m as runD1RankMigrations,p as runD1SearchMigrations,l as selectGlobalTables,T as sqliteDialect,C as trimD1CdcChanges};
+import{exportGlobalRows as o,importGlobalRows as a,selectGlobalTables as t}from"./packem_shared/exportGlobalRows-Cc8cXltm.mjs";import{D1Client as i,D1Session as n}from"./packem_shared/D1Client-CzS0Qfa6.mjs";import{backfillD1SearchIndexes as D,createD1CtxDb as b,readD1CdcChanges as g,runD1AggregateMigrations as x,runD1CdcMigration as c,runD1GlobalTableMigrations as m,runD1RankMigrations as f,runD1SearchMigrations as p,trimD1CdcChanges as u}from"./packem_shared/backfillD1SearchIndexes-By6bbCLe.mjs";import{facetGlobalColumn as d,listGlobalTables as G,readGlobalTablePage as M}from"./packem_shared/facetGlobalColumn-D1npxpva.mjs";import{MigrationRunner as h}from"./packem_shared/MigrationRunner-SadkIbU5.mjs";import{D1TimeoutError as S,isTransientD1Error as w,retryingExec as E,withD1Retry as k}from"./packem_shared/D1TimeoutError-D4YUqZPk.mjs";import{default as y}from"./packem_shared/sqliteDialect-DZoYJOa-.mjs";import{createSqlCtxDb as I}from"@lunora/sql-store";export{i as D1Client,n as D1Session,S as D1TimeoutError,h as MigrationRunner,D as backfillD1SearchIndexes,b as createD1CtxDb,I as createSqlCtxDb,o as exportGlobalRows,d as facetGlobalColumn,a as importGlobalRows,w as isTransientD1Error,G as listGlobalTables,g as readD1CdcChanges,M as readGlobalTablePage,E as retryingExec,x as runD1AggregateMigrations,c as runD1CdcMigration,m as runD1GlobalTableMigrations,f as runD1RankMigrations,p as runD1SearchMigrations,t as selectGlobalTables,y as sqliteDialect,u as trimD1CdcChanges,k as withD1Retry};

package/dist/packem_shared/D1Client-CzS0Qfa6.mjs

@@ -0,0 +1 @@
+import{drizzle as i}from"drizzle-orm/d1";import{isReadOnlyD1Sql as o,withD1Retry as a}from"./D1TimeoutError-D4YUqZPk.mjs";const c=(s,e)=>{if(s.size<e)return;const t=s.keys().next().value;t!==void 0&&s.delete(t)},l=256,h=(s,e,t)=>{const r=s.get(t);if(r)return s.delete(t),s.set(t,r),r;const n=e(t);return c(s,l),s.set(t,n),n},d="first-unconstrained";class u{session;stmtCache=new Map;constructor(e){this.session=e}prepare(e){return h(this.stmtCache,t=>this.session.prepare(t),e)}async run(e,...t){return this.prepare(e).bind(...t).run()}async all(e,...t){const r=async()=>this.prepare(e).bind(...t).all();return o(e)?a(r):r()}async first(e,...t){const r=async()=>this.prepare(e).bind(...t).first();return o(e)?a(r):r()}getBookmark(){return this.session.getBookmark()??void 0}}class b{db;stmtCache=new Map;drizzleHandle;constructor(e){this.db=e}withSession(e){const t=this.db.withSession(e??d);return new u(t)}prepare(e){return h(this.stmtCache,t=>this.db.prepare(t),e)}get drizzle(){return this.drizzleHandle?this.drizzleHandle:(this.drizzleHandle=i(this.db,{logger:!1}),this.drizzleHandle)}drizzleSession(e){const t=this.db.withSession(e??d);return i(t,{logger:!1})}async batch(e){return this.drizzle.batch(e)}get raw(){return this.db}}export{b as D1Client,u as D1Session};

package/dist/packem_shared/D1TimeoutError-D4YUqZPk.mjs

@@ -0,0 +1 @@
+import{LunoraError as h,unreachable as f}from"@lunora/errors";const y=["storage operation exceeded timeout","network connection lost","internal error while starting up d1 db storage","exceeded its memory limit","caused object to be reset"],M=3,S=50,b=1e3,D=2e3,p=/^[\s(]*(?:select|pragma|explain)\b/iu,_=t=>p.test(t),A=t=>t instanceof Error?`${t.name}: ${t.message}`.toLowerCase():typeof t=="string"?t.toLowerCase():"",I=t=>{const e=A(t);return e.length===0?!1:y.some(n=>e.includes(n))},N=t=>{const e=Math.min(b,S*2**(t-1));return Math.round(Math.random()*e)},L=async t=>new Promise(e=>{setTimeout(e,t)});class l extends Error{timeoutMs;constructor(e){super(`@lunora/d1: operation exceeded its ${String(e)}ms timeout and was abandoned (the underlying D1 call may still be running)`),this.name="D1TimeoutError",this.timeoutMs=e}}const R=async(t,e)=>{let n;try{return await Promise.race([t(),new Promise((o,r)=>{n=setTimeout(()=>{r(new l(e))},e)})])}finally{n!==void 0&&clearTimeout(n)}},x=async(t,e={})=>{const n=e.attempts??M;if(!Number.isInteger(n)||n<1)throw new h("BAD_REQUEST","@lunora/d1: `attempts` must be an integer >= 1");const o=e.sleep??L,{deadlineMs:r,timeoutMs:i}=e,d=Date.now(),w=r===void 0&&i===void 0,c=()=>r===void 0?Number.POSITIVE_INFINITY:r-(Date.now()-d);for(let s=1;s<=n;s+=1){const u=Math.min(i??Number.POSITIVE_INFINITY,Math.max(c(),0)),E=Date.now();try{return await(Number.isFinite(u)?R(t,u):t())}catch(a){const g=a instanceof l||I(a),T=w&&Date.now()-E>=D,m=c();if(s===n||!g||T||m<=0)throw a;await o(Math.min(N(s),m))}}return f("@lunora/d1: retry loop exited without returning or throwing")},P=(t,e)=>({...t,all:async(n,o)=>_(n)?x(async()=>t.all(n,o),e):t.all(n,o)});export{l as D1TimeoutError,_ as isReadOnlyD1Sql,I as isTransientD1Error,P as retryingExec,x as withD1Retry};

package/dist/packem_shared/{MigrationRunner-IF213ALw.mjs → MigrationRunner-SadkIbU5.mjs}

@@ -1,2 +1,2 @@
-import{LunoraError as f}from"@lunora/errors";import{sql as h}from"drizzle-orm";import{D1Client as m}from"./D1Client-IzEOlt9I.mjs";const u="__drizzle_migrations",p=`CREATE TABLE IF NOT EXISTS ${u} (id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL UNIQUE, created_at NUMERIC)`,d=/\s/u,E=/^[0-9a-f]{64}$/u,S=new RegExp(String.raw`UNIQUE constraint failed:\s*${u}\.hash`,"iu"),w=c=>{const n=c.sql;let e=!1,i=!1,o=!1,a=!1,r;for(let t=0;t<n.length;t+=1){const s=n[t],l=n[t+1];if(o){s===`
+import{LunoraError as f}from"@lunora/errors";import{sql as h}from"drizzle-orm";import{D1Client as m}from"./D1Client-CzS0Qfa6.mjs";const u="__drizzle_migrations",p=`CREATE TABLE IF NOT EXISTS ${u} (id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL UNIQUE, created_at NUMERIC)`,d=/\s/u,E=/^[0-9a-f]{64}$/u,S=new RegExp(String.raw`UNIQUE constraint failed:\s*${u}\.hash`,"iu"),w=c=>{const n=c.sql;let e=!1,i=!1,o=!1,a=!1,r;for(let t=0;t<n.length;t+=1){const s=n[t],l=n[t+1];if(o){s===`
 `&&(o=!1);continue}if(a){s==="*"&&l==="/"&&(a=!1,t+=1);continue}if(e){s==="'"&&(l==="'"?t+=1:e=!1);continue}if(i){s==='"'&&(l==='"'?t+=1:i=!1);continue}if(s==="-"&&l==="-"){o=!0,t+=1;continue}if(s==="/"&&l==="*"){a=!0,t+=1;continue}if(r!==void 0){if(s!==void 0&&!d.test(s))throw new f("INTERNAL",`Migration "${c.name}" (v${String(c.version)}) contains more than one SQL statement. Split it into separate migrations — batch() runs them atomically.`);continue}if(s==="'"){e=!0;continue}if(s==='"'){i=!0;continue}s===";"&&(r=t)}return r},g=async c=>{const n=new TextEncoder().encode(c),e=await crypto.subtle.digest("SHA-256",n);return[...new Uint8Array(e)].map(i=>i.toString(16).padStart(2,"0")).join("")};class A{client;migrations;constructor(n,e){this.client=n instanceof m?n:new m(n),this.migrations=[...e].toSorted((i,o)=>i.version-o.version),this.assertUniqueVersions(),this.assertUniqueSql()}async run(){await this.client.drizzle.run(h.raw(p));const n=await this.client.drizzle.all(h.raw(`SELECT hash FROM ${u}`)),e=new Set(n.map(r=>r.hash)),i=[],o=[],a=await Promise.all(this.migrations.map(async r=>g(r.sql)));for(const[r,t]of this.migrations.entries()){const s=a[r];if(e.has(s)){o.push({name:t.name,version:t.version});continue}await this.applyOne(t,s)?i.push({name:t.name,version:t.version}):o.push({name:t.name,version:t.version})}return{applied:i,skipped:o}}async applyOne(n,e){const i=w(n),o=(i===void 0?n.sql:n.sql.slice(0,i)).trim();if(!E.test(e))throw new f("INTERNAL",`migration "${n.name}" produced a non-hex hash; refusing to inline into SQL`);const a=`INSERT INTO ${u} (hash, created_at) VALUES ('${e}', ${String(Date.now())})`,r=[this.client.drizzle.run(h.raw(o)),this.client.drizzle.run(h.raw(a))];try{await this.client.batch(r)}catch(t){if(S.test(t instanceof Error?t.message:String(t)))return!1;throw t}return!0}assertUniqueVersions(){const n=new Set;for(const e of this.migrations){if(n.has(e.version))throw new f("INTERNAL",`Duplicate migration version ${String(e.version)}`);n.add(e.version)}}assertUniqueSql(){const n=new Map;for(const e of this.migrations){const i=n.get(e.sql);if(i!==void 0)throw new f("INTERNAL",`Migrations ${String(i)} and ${String(e.version)} have identical SQL — bump the content, not just the version.`);n.set(e.sql,e.version)}}}export{A as MigrationRunner};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/d1",
-  "version": "1.0.0-alpha.79",
+  "version": "1.0.0-alpha.80",
   "description": "D1 adapter for Lunora .global() tables, wrapping the Sessions API for read-your-writes",
   "keywords": [
     "cloudflare",
@@ -51,9 +51,9 @@
   },
   "dependencies": {
     "@lunora/errors": "1.0.0-alpha.22",
-    "@lunora/platform": "1.0.0-alpha.12",
-    "@lunora/shard-engine": "1.0.0-alpha.29",
-    "@lunora/sql-store": "1.0.0-alpha.81",
+    "@lunora/platform": "1.0.0-alpha.13",
+    "@lunora/shard-engine": "1.0.0-alpha.30",
+    "@lunora/sql-store": "1.0.0-alpha.82",
     "drizzle-orm": "^0.45.2"
   },
   "engines": {

package/dist/packem_shared/D1Client-IzEOlt9I.mjs

@@ -1 +0,0 @@
-import{drizzle as i}from"drizzle-orm/d1";const a=(s,e)=>{if(s.size<e)return;const t=s.keys().next().value;t!==void 0&&s.delete(t)},h=256,d=(s,e,t)=>{const r=s.get(t);if(r)return s.delete(t),s.set(t,r),r;const n=e(t);return a(s,h),s.set(t,n),n},o="first-unconstrained";class l{session;stmtCache=new Map;constructor(e){this.session=e}prepare(e){return d(this.stmtCache,t=>this.session.prepare(t),e)}async run(e,...t){return this.prepare(e).bind(...t).run()}async all(e,...t){return this.prepare(e).bind(...t).all()}async first(e,...t){return this.prepare(e).bind(...t).first()}getBookmark(){return this.session.getBookmark()??void 0}}class u{db;stmtCache=new Map;drizzleHandle;constructor(e){this.db=e}withSession(e){const t=this.db.withSession(e??o);return new l(t)}prepare(e){return d(this.stmtCache,t=>this.db.prepare(t),e)}get drizzle(){return this.drizzleHandle?this.drizzleHandle:(this.drizzleHandle=i(this.db,{logger:!1}),this.drizzleHandle)}drizzleSession(e){const t=this.db.withSession(e??o);return i(t,{logger:!1})}async batch(e){return this.drizzle.batch(e)}get raw(){return this.db}}export{u as D1Client,l as D1Session};