@rexezuge/d1 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rexezuge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/BaseDAO.d.ts

@@ -0,0 +1,77 @@
+import { D1_RETRY_DEFAULTS } from './D1Retry';
+import type { D1PreparedStatement, D1Queryable, D1Result } from './D1Types';
+/**
+ * Canonical DAO base: retry is a policy, methods are a promise.
+ *
+ * Converged from the nine consumer repos' `BaseDAO`s, which had drifted into
+ * seven spellings of the same idea (`withRetry`, `runWithRetry`,
+ * `runWriteStatement`, `firstWithRetry`, `allWithRetry`, `runWriteBatch`, plus
+ * Mail-Meow's static `findById`). The kit ships one straight-line surface —
+ * **clients adapt to these names** — with the non-DAO concerns extracted:
+ *
+ * - cursor pagination moved to `@rexezuge/shared`'s `CursorCodec` (it is a
+ *   codec, not a DAO method);
+ * - subrequest accounting became an injected concern, so the seven repos that
+ *   never needed it do not inherit it;
+ * - retry policy lives in `D1Retry` — one schedule, one classifier, one place
+ *   the `Failed to <context>` prefix is added.
+ *
+ * Identifier safety: `table`/`column` names cannot be bound, so the two methods
+ * that interpolate them (`deleteOlderThan`) allow-list each segment against
+ * `/^[A-Za-z_][A-Za-z0-9_]*$/`. Everything else in a statement goes through
+ * `.bind()`.
+ */
+declare abstract class BaseDAO {
+    protected readonly database: D1Queryable;
+    protected constructor(database: D1Queryable);
+    /**
+     * A mutating statement with retry and a guaranteed `DatabaseError` on
+     * failure. Every write in this layer goes through here: hand-rolling
+     * `.run()` plus `if (!result.success) throw` silently produced
+     * `retryable: false` and skipped the retry entirely — which left the most
+     * failure-sensitive writes with no recovery from a transient D1 lock.
+     */
+    protected run(statement: () => Promise<D1Result>, context: string): Promise<D1Result>;
+    /**
+     * A point read. `first()` resolving to `null` is "no row", a success, not an
+     * error — only a rejected statement is retried and normalized.
+     */
+    protected first<T>(statement: () => Promise<T | null>, context: string): Promise<T | null>;
+    /**
+     * A list read. `.all()` returning `[]` is a success like `first()`'s `null`.
+     * Separate from `run` because that one is typed for a write's `D1Result`;
+     * a list read had no retry at all in the drifted copies.
+     */
+    protected all<T>(statement: () => Promise<{
+        results?: T[];
+    }>, context: string): Promise<T[]>;
+    /** A scalar count from a `SELECT count(*) AS count` row; 0 when absent. */
+    protected count(statement: () => Promise<{
+        count: number;
+    } | null>, context: string): Promise<number>;
+    /**
+     * A batch of prepared statements, retried as a unit and unwrapped to the
+     * per-statement results D1 returns. A single non-success result inside the
+     * batch is what the engine classifies and retries.
+     */
+    protected batch(statements: D1PreparedStatement[], context: string): Promise<D1Result[]>;
+    /**
+     * Generic batched delete of rows older than a cutoff, in ID order, with
+     * retry. Mirrors the per-DAO `DELETE ... WHERE id IN (SELECT ... LIMIT ?)`
+     * pattern that every repo re-implemented per table.
+     *
+     * `timeColumn` is compared against `<` — the cutoff is exclusive, so a
+     * delete never touches a row at exactly the boundary timestamp.
+     */
+    protected static deleteOlderThan(db: D1Queryable, table: string, timeColumn: string, cutoff: number | string, limit: number, idColumn: string): Promise<number>;
+    /** The retry schedule, for callers that surface it (health checks, tests). */
+    protected static get retryDefaults(): typeof D1_RETRY_DEFAULTS;
+}
+/**
+ * Allow-list one SQL identifier segment. Values never go through this — they
+ * are always bound; this exists purely for the table/column names that
+ * parameter binding cannot express.
+ */
+declare function assertSqlIdentifier(value: string, label: string): void;
+export { BaseDAO, assertSqlIdentifier };
+//# sourceMappingURL=BaseDAO.d.ts.map

package/dist/BaseDAO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseDAO.d.ts","sourceRoot":"","sources":["../src/BaseDAO.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAoB,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAU5E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uBAAe,OAAO;IACE,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW;IAA9D,SAAS,aAAgC,QAAQ,EAAE,WAAW;IAE9D;;;;;;OAMG;cACa,GAAG,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAI3F;;;OAGG;cACa,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAQhG;;;;OAIG;cACa,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;QAAE,OAAO,CAAC,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAQlG,2EAA2E;cAC3D,KAAK,CACnB,SAAS,EAAE,MAAM,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,EAClD,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC;IAKlB;;;;OAIG;cACa,KAAK,CAAC,UAAU,EAAE,mBAAmB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAgB9F;;;;;;;OAOG;qBACoB,eAAe,CACpC,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC;IAsBlB,8EAA8E;IAC9E,SAAS,CAAC,MAAM,KAAK,aAAa,IAAI,OAAO,iBAAiB,CAE7D;CACF;AAED;;;;GAIG;AACH,iBAAS,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI/D;AAED,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/BaseDAO.js

@@ -0,0 +1,126 @@
+import { DatabaseError } from '@rexezuge/errors';
+import { D1_RETRY_DEFAULTS, executeWithRetry } from './D1Retry';
+/**
+ * Canonical DAO base: retry is a policy, methods are a promise.
+ *
+ * Converged from the nine consumer repos' `BaseDAO`s, which had drifted into
+ * seven spellings of the same idea (`withRetry`, `runWithRetry`,
+ * `runWriteStatement`, `firstWithRetry`, `allWithRetry`, `runWriteBatch`, plus
+ * Mail-Meow's static `findById`). The kit ships one straight-line surface —
+ * **clients adapt to these names** — with the non-DAO concerns extracted:
+ *
+ * - cursor pagination moved to `@rexezuge/shared`'s `CursorCodec` (it is a
+ *   codec, not a DAO method);
+ * - subrequest accounting became an injected concern, so the seven repos that
+ *   never needed it do not inherit it;
+ * - retry policy lives in `D1Retry` — one schedule, one classifier, one place
+ *   the `Failed to <context>` prefix is added.
+ *
+ * Identifier safety: `table`/`column` names cannot be bound, so the two methods
+ * that interpolate them (`deleteOlderThan`) allow-list each segment against
+ * `/^[A-Za-z_][A-Za-z0-9_]*$/`. Everything else in a statement goes through
+ * `.bind()`.
+ */
+class BaseDAO {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    /**
+     * A mutating statement with retry and a guaranteed `DatabaseError` on
+     * failure. Every write in this layer goes through here: hand-rolling
+     * `.run()` plus `if (!result.success) throw` silently produced
+     * `retryable: false` and skipped the retry entirely — which left the most
+     * failure-sensitive writes with no recovery from a transient D1 lock.
+     */
+    async run(statement, context) {
+        return executeWithRetry(statement, context);
+    }
+    /**
+     * A point read. `first()` resolving to `null` is "no row", a success, not an
+     * error — only a rejected statement is retried and normalized.
+     */
+    async first(statement, context) {
+        const envelope = await executeWithRetry(async () => {
+            const value = await statement();
+            return { success: true, value };
+        }, context);
+        return envelope.value;
+    }
+    /**
+     * A list read. `.all()` returning `[]` is a success like `first()`'s `null`.
+     * Separate from `run` because that one is typed for a write's `D1Result`;
+     * a list read had no retry at all in the drifted copies.
+     */
+    async all(statement, context) {
+        const envelope = await executeWithRetry(async () => {
+            const rows = await statement();
+            return { success: true, value: rows.results ?? [] };
+        }, context);
+        return envelope.value;
+    }
+    /** A scalar count from a `SELECT count(*) AS count` row; 0 when absent. */
+    async count(statement, context) {
+        const row = await this.first(statement, context);
+        return row?.count ?? 0;
+    }
+    /**
+     * A batch of prepared statements, retried as a unit and unwrapped to the
+     * per-statement results D1 returns. A single non-success result inside the
+     * batch is what the engine classifies and retries.
+     */
+    async batch(statements, context) {
+        if (this.database.batch === undefined) {
+            throw new DatabaseError(`Batch is not supported for ${context}: the D1 binding exposes no batch()`);
+        }
+        const envelope = await executeWithRetry(async () => {
+            const results = await this.database.batch(statements);
+            const failed = results.find((result) => !result.success);
+            return {
+                success: failed === undefined,
+                error: failed?.error,
+                value: results,
+            };
+        }, context);
+        return envelope.value;
+    }
+    /**
+     * Generic batched delete of rows older than a cutoff, in ID order, with
+     * retry. Mirrors the per-DAO `DELETE ... WHERE id IN (SELECT ... LIMIT ?)`
+     * pattern that every repo re-implemented per table.
+     *
+     * `timeColumn` is compared against `<` — the cutoff is exclusive, so a
+     * delete never touches a row at exactly the boundary timestamp.
+     */
+    static async deleteOlderThan(db, table, timeColumn, cutoff, limit, idColumn) {
+        assertSqlIdentifier(table, 'table');
+        assertSqlIdentifier(timeColumn, 'timeColumn');
+        assertSqlIdentifier(idColumn, 'idColumn');
+        const result = await executeWithRetry(() => db
+            .prepare(`DELETE FROM ${table}
+             WHERE ${idColumn} IN (
+               SELECT ${idColumn} FROM ${table}
+               WHERE ${timeColumn} < ?
+               LIMIT ?
+             )`)
+            .bind(cutoff, limit)
+            .run(), `delete old rows from ${table}`);
+        return result.meta?.changes ?? 0;
+    }
+    /** The retry schedule, for callers that surface it (health checks, tests). */
+    static get retryDefaults() {
+        return D1_RETRY_DEFAULTS;
+    }
+}
+/**
+ * Allow-list one SQL identifier segment. Values never go through this — they
+ * are always bound; this exists purely for the table/column names that
+ * parameter binding cannot express.
+ */
+function assertSqlIdentifier(value, label) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+        throw new Error(`Unsafe SQL identifier for ${label}: ${JSON.stringify(value)}`);
+    }
+}
+export { BaseDAO, assertSqlIdentifier };
+//# sourceMappingURL=BaseDAO.js.map

package/dist/BaseDAO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseDAO.js","sourceRoot":"","sources":["../src/BaseDAO.ts"],"names":[],"mappings":"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"}

package/dist/D1ErrorClassifier.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Classify a raw D1 (or DO SQLite) error message as transient or permanent.
+ *
+ * Converged verbatim from Durable-DAV (and ChordDHT's byte-identical copy,
+ * modulo the import scope) — the most-documented variant in the family.
+ */
+/**
+ * Patterns for a transient failure worth retrying.
+ *
+ * Checked **first**. A message matching both lists is treated as transient: one
+ * wasted round trip against a real conflict is cheap, whereas mis-classifying a
+ * blip as permanent turns a self-healing condition into a user-visible outage
+ * that neither the DAO's retry nor the API's 503 mapping will cover.
+ */
+declare const RETRYABLE_PATTERNS: RegExp[];
+/**
+ * Patterns for a failure that will not get better on its own.
+ *
+ * Every entry is deliberately **narrower than its obvious spelling**. This list
+ * used to be consulted first and carried bare `/range/i` and `/not\s+found/i`,
+ * both of which match transient conditions:
+ *
+ * - `/range/i` matched `RangeError: Maximum call stack size exceeded` and
+ *   `byte range not satisfiable` — neither is a row-level conflict.
+ * - `/not\s+found/i` matched `host not found`, i.e. a DNS blip, which
+ *   `/connection/i` now correctly claims first.
+ */
+declare const NON_RETRYABLE_PATTERNS: RegExp[];
+declare function isD1ErrorRetryable(errorMessage: string): boolean;
+export { isD1ErrorRetryable, RETRYABLE_PATTERNS, NON_RETRYABLE_PATTERNS };
+//# sourceMappingURL=D1ErrorClassifier.d.ts.map

package/dist/D1ErrorClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1ErrorClassifier.d.ts","sourceRoot":"","sources":["../src/D1ErrorClassifier.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,QAAA,MAAM,kBAAkB,EAAE,MAAM,EAc/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,sBAAsB,EAAE,MAAM,EAiBnC,CAAC;AAEF,iBAAS,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAmBzD;AAED,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/D1ErrorClassifier.js

@@ -0,0 +1,81 @@
+/**
+ * Classify a raw D1 (or DO SQLite) error message as transient or permanent.
+ *
+ * Converged verbatim from Durable-DAV (and ChordDHT's byte-identical copy,
+ * modulo the import scope) — the most-documented variant in the family.
+ */
+/**
+ * Patterns for a transient failure worth retrying.
+ *
+ * Checked **first**. A message matching both lists is treated as transient: one
+ * wasted round trip against a real conflict is cheap, whereas mis-classifying a
+ * blip as permanent turns a self-healing condition into a user-visible outage
+ * that neither the DAO's retry nor the API's 503 mapping will cover.
+ */
+const RETRYABLE_PATTERNS = [
+    /busy/i,
+    /locked/i,
+    /timeout/i,
+    /timed?\s*out/i,
+    /internal\s+(server\s+)?error/i,
+    /connection/i,
+    /network/i,
+    /unavailable/i,
+    /throttl/i,
+    /too\s+many/i,
+    /retry/i,
+    /deadlock/i,
+    /serialization/i,
+];
+/**
+ * Patterns for a failure that will not get better on its own.
+ *
+ * Every entry is deliberately **narrower than its obvious spelling**. This list
+ * used to be consulted first and carried bare `/range/i` and `/not\s+found/i`,
+ * both of which match transient conditions:
+ *
+ * - `/range/i` matched `RangeError: Maximum call stack size exceeded` and
+ *   `byte range not satisfiable` — neither is a row-level conflict.
+ * - `/not\s+found/i` matched `host not found`, i.e. a DNS blip, which
+ *   `/connection/i` now correctly claims first.
+ */
+const NON_RETRYABLE_PATTERNS = [
+    /constraint/i,
+    /\bunique\b/i,
+    /primary\s+key/i,
+    /foreign\s+key/i,
+    /not\s+found/i,
+    /\bsyntax\b/i,
+    /parse\s+error/i,
+    /no\s+such\s+(table|column|index)/i,
+    /type\s+mismatch/i,
+    // Was `/range/i`, which also matched a stack-overflow `RangeError` and
+    // "byte range not satisfiable".
+    /\bout\s+of\s+range\b/i,
+    /invalid\s+argument/i,
+    /\bpermission\b/i,
+    /\bauthorization\b/i,
+    /\bauthentication\b/i,
+];
+function isD1ErrorRetryable(errorMessage) {
+    if (!errorMessage)
+        return false;
+    // Retryable is checked first on purpose. An error can carry both a transient
+    // signal and a permanent-sounding word — "connection: host not found",
+    // "retry: authentication backend unavailable" — and retrying those is correct,
+    // while a bare "row not found" or a UNIQUE/FOREIGN KEY violation still matches
+    // nothing in the retryable list and is correctly refused. The ordering is
+    // pinned by `hardening-round7.test.ts` in Durable-DAV; the kit carries the
+    // equivalent expectations in d1.test.ts.
+    for (const pattern of RETRYABLE_PATTERNS) {
+        if (pattern.test(errorMessage))
+            return true;
+    }
+    for (const pattern of NON_RETRYABLE_PATTERNS) {
+        if (pattern.test(errorMessage))
+            return false;
+    }
+    return false;
+}
+export { isD1ErrorRetryable, RETRYABLE_PATTERNS, NON_RETRYABLE_PATTERNS };
+//# sourceMappingURL=D1ErrorClassifier.js.map

package/dist/D1ErrorClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1ErrorClassifier.js","sourceRoot":"","sources":["../src/D1ErrorClassifier.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,MAAM,kBAAkB,GAAa;IACnC,OAAO;IACP,SAAS;IACT,UAAU;IACV,eAAe;IACf,+BAA+B;IAC/B,aAAa;IACb,UAAU;IACV,cAAc;IACd,UAAU;IACV,aAAa;IACb,QAAQ;IACR,WAAW;IACX,gBAAgB;CACjB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,sBAAsB,GAAa;IACvC,aAAa;IACb,aAAa;IACb,gBAAgB;IAChB,gBAAgB;IAChB,cAAc;IACd,aAAa;IACb,gBAAgB;IAChB,mCAAmC;IACnC,kBAAkB;IAClB,uEAAuE;IACvE,gCAAgC;IAChC,uBAAuB;IACvB,qBAAqB;IACrB,iBAAiB;IACjB,oBAAoB;IACpB,qBAAqB;CACtB,CAAC;AAEF,SAAS,kBAAkB,CAAC,YAAoB;IAC9C,IAAI,CAAC,YAAY;QAAE,OAAO,KAAK,CAAC;IAEhC,6EAA6E;IAC7E,uEAAuE;IACvE,+EAA+E;IAC/E,+EAA+E;IAC/E,0EAA0E;IAC1E,2EAA2E;IAC3E,yCAAyC;IACzC,KAAK,MAAM,OAAO,IAAI,kBAAkB,EAAE,CAAC;QACzC,IAAI,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC;YAAE,OAAO,IAAI,CAAC;IAC9C,CAAC;IAED,KAAK,MAAM,OAAO,IAAI,sBAAsB,EAAE,CAAC;QAC7C,IAAI,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC;YAAE,OAAO,KAAK,CAAC;IAC/C,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/D1Retry.d.ts

@@ -0,0 +1,40 @@
+import type { D1Result } from './D1Types';
+/**
+ * The retry schedule, exported so `BaseDAO` and any other caller cannot
+ * hard-code a second, divergent one — re-deriving `baseDelayMs * 2 ** n` at a
+ * call site is the same drift one level up.
+ */
+declare const D1_RETRY_DEFAULTS: {
+    readonly maxRetries: 3;
+    readonly baseDelayMs: 100;
+};
+interface D1RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+}
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Backoff before the next attempt. Exponential, and uncapped by design: the
+ * default base (100 ms) tops out under a second by attempt 3, while an operator
+ * who sets a larger base gets the longer wait they asked for. The point is to
+ * ride out a busy/locked D1, not to implement a rate limiter.
+ */
+declare function backoffMs(baseDelayMs: number, attempt: number): number;
+/**
+ * Run a D1 operation, retrying transient failures with exponential backoff.
+ *
+ * Two failure shapes are handled, because D1 reports both:
+ *
+ * 1. **A result with `success: false`.** The operation resolved; the database
+ *    said no. Retried when the error classifies as transient.
+ * 2. **A thrown error.** A transport-level rejection, which never carries a
+ *    `D1Result` at all. Classified from the message the same way.
+ *
+ * A `DatabaseError` we raised ourselves in (1) arrives back through the `catch`
+ * on the retry attempt, so it must be recognised and re-thrown rather than
+ * re-wrapped into a second layer of `Failed to …`.
+ */
+declare function executeWithRetry<T extends D1Result>(operation: () => Promise<T>, context: string, options?: D1RetryOptions): Promise<T>;
+export { backoffMs, D1_RETRY_DEFAULTS, executeWithRetry, sleep };
+export type { D1RetryOptions };
+//# sourceMappingURL=D1Retry.d.ts.map

package/dist/D1Retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1Retry.d.ts","sourceRoot":"","sources":["../src/D1Retry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAgB1C;;;;GAIG;AACH,QAAA,MAAM,iBAAiB;;;CAAmF,CAAC;AAE3G,UAAU,cAAc;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,iBAAS,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExC;AAED;;;;;GAKG;AACH,iBAAS,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D;AAMD;;;;;;;;;;;;;GAaG;AACH,iBAAe,gBAAgB,CAAC,CAAC,SAAS,QAAQ,EAChD,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,CAAC,CAAC,CA0CZ;AAED,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC;AACjE,YAAY,EAAE,cAAc,EAAE,CAAC"}

package/dist/D1Retry.js

@@ -0,0 +1,94 @@
+import { DatabaseError } from '@rexezuge/errors';
+import { isD1ErrorRetryable } from './D1ErrorClassifier';
+/**
+ * The single retry engine for D1 statements.
+ *
+ * Converged from Durable-DAV's `D1Utils.ts` (the richest, most-documented
+ * variant) with ChordDHT's byte-identical copy and the straight-line port in
+ * Mail-Meow. The seven consumer repos each spelled this differently
+ * (`executeD1WithRetry`, `runWithRetry`, `firstWithRetry` with its own schedule);
+ * the kit ships one engine plus the schedule constants, and `BaseDAO` is the
+ * only intended caller.
+ */
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 100;
+/**
+ * The retry schedule, exported so `BaseDAO` and any other caller cannot
+ * hard-code a second, divergent one — re-deriving `baseDelayMs * 2 ** n` at a
+ * call site is the same drift one level up.
+ */
+const D1_RETRY_DEFAULTS = { maxRetries: DEFAULT_MAX_RETRIES, baseDelayMs: DEFAULT_BASE_DELAY_MS };
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Backoff before the next attempt. Exponential, and uncapped by design: the
+ * default base (100 ms) tops out under a second by attempt 3, while an operator
+ * who sets a larger base gets the longer wait they asked for. The point is to
+ * ride out a busy/locked D1, not to implement a rate limiter.
+ */
+function backoffMs(baseDelayMs, attempt) {
+    return baseDelayMs * 2 ** attempt;
+}
+function toDatabaseError(errorMessage, context) {
+    return new DatabaseError(`Failed to ${context}: ${errorMessage}`, isD1ErrorRetryable(errorMessage));
+}
+/**
+ * Run a D1 operation, retrying transient failures with exponential backoff.
+ *
+ * Two failure shapes are handled, because D1 reports both:
+ *
+ * 1. **A result with `success: false`.** The operation resolved; the database
+ *    said no. Retried when the error classifies as transient.
+ * 2. **A thrown error.** A transport-level rejection, which never carries a
+ *    `D1Result` at all. Classified from the message the same way.
+ *
+ * A `DatabaseError` we raised ourselves in (1) arrives back through the `catch`
+ * on the retry attempt, so it must be recognised and re-thrown rather than
+ * re-wrapped into a second layer of `Failed to …`.
+ */
+async function executeWithRetry(operation, context, options) {
+    const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const baseDelayMs = options?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const isLastAttempt = attempt === maxRetries;
+        try {
+            const result = await operation();
+            if (result.success)
+                return result;
+            const errorMessage = result.error ?? 'Unknown database error';
+            const failure = toDatabaseError(errorMessage, context);
+            if (!isLastAttempt && failure.retryable) {
+                await sleep(backoffMs(baseDelayMs, attempt));
+                continue;
+            }
+            throw failure;
+        }
+        catch (error) {
+            // Already classified above, or raised by the operation itself. Either way
+            // re-wrapping would bury the original context.
+            if (error instanceof DatabaseError) {
+                if (!isLastAttempt && error.retryable) {
+                    await sleep(backoffMs(baseDelayMs, attempt));
+                    continue;
+                }
+                throw error;
+            }
+            if (error instanceof Error) {
+                const failure = toDatabaseError(error.message, context);
+                if (!isLastAttempt && failure.retryable) {
+                    await sleep(backoffMs(baseDelayMs, attempt));
+                    continue;
+                }
+                throw failure;
+            }
+            throw error;
+        }
+    }
+    // Unreachable: the loop either returns a result or throws on its final
+    // iteration. Present only so the function is total for a reader who has not
+    // traced the `continue` paths.
+    throw new DatabaseError(`Failed to ${context} after ${maxRetries + 1} attempts`);
+}
+export { backoffMs, D1_RETRY_DEFAULTS, executeWithRetry, sleep };
+//# sourceMappingURL=D1Retry.js.map

package/dist/D1Retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1Retry.js","sourceRoot":"","sources":["../src/D1Retry.ts"],"names":[],"mappings":"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"}

package/dist/D1Types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal structural D1 types so `@rexezuge/d1` typechecks without
+ * @cloudflare/workers-types. A real `D1Database` satisfies these structurally.
+ *
+ * Converged from the identical copies in the nine consumer repos.
+ */
+interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    first<T = unknown>(): Promise<T | null>;
+    all<T = unknown>(): Promise<{
+        results: T[];
+    }>;
+    run(): Promise<D1Result>;
+}
+interface D1Result {
+    success: boolean;
+    error?: string;
+    meta?: {
+        changes?: number;
+        [key: string]: unknown;
+    };
+}
+interface D1Queryable {
+    prepare(query: string): D1PreparedStatement;
+    batch?(statements: D1PreparedStatement[]): Promise<D1Result[]>;
+}
+export type { D1PreparedStatement, D1Queryable, D1Result };
+//# sourceMappingURL=D1Types.d.ts.map

package/dist/D1Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1Types.d.ts","sourceRoot":"","sources":["../src/D1Types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,UAAU,mBAAmB;IAC3B,IAAI,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,mBAAmB,CAAC;IAChD,KAAK,CAAC,CAAC,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACxC,GAAG,CAAC,CAAC,GAAG,OAAO,KAAK,OAAO,CAAC;QAAE,OAAO,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC,CAAC;IAC9C,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1B;AAED,UAAU,QAAQ;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;CACrD;AAED,UAAU,WAAW;IACnB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAAC;IAC5C,KAAK,CAAC,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;CAChE;AAED,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC"}

package/dist/D1Types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=D1Types.js.map

package/dist/D1Types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1Types.js","sourceRoot":"","sources":["../src/D1Types.ts"],"names":[],"mappings":""}

package/dist/aes-gcm.d.ts

@@ -0,0 +1,44 @@
+/**
+ * AES-GCM envelope for values that must be recoverable.
+ *
+ * Converged from the seven drifted copies of `backend-data/crypto/aes-gcm.ts`
+ * (AWS, CalDAV, Durable-DAV, Edge-Git, Edge-Sonic, Mail-Meow, Mail-Otter).
+ * Durable-DAV's is the canonical shape; names are de-scoped from
+ * "replication" because every repo that encrypts a secret — replication remote
+ * passwords, SES credentials, OAuth client secrets — has the same problem.
+ *
+ * Key material is base64 of exactly 32 bytes. A missing or wrong-sized key
+ * throws rather than returning plaintext: the alternative — a helper that
+ * quietly passes the value through when it cannot encrypt — would store the
+ * secret in the clear on exactly the deployments that forgot to configure a
+ * key, and nothing would report it.
+ */
+declare const KEY_BYTES = 32;
+declare const IV_BYTES = 12;
+declare class AesGcmKeyError extends Error {
+    constructor(message: string);
+}
+interface EncryptedEnvelope {
+    ciphertext: string;
+    iv: string;
+}
+/**
+ * Encrypt one secret. The IV is random per call and returned alongside the
+ * ciphertext so the caller can store the pair — reusing an IV under one key
+ * destroys GCM's security guarantees outright, which is why it is not
+ * internal to the ciphertext.
+ */
+declare function encryptSecret(plaintext: string, encodedKey: string | undefined | null): Promise<EncryptedEnvelope>;
+/**
+ * Decrypt one envelope.
+ *
+ * Throws on a wrong key or tampered ciphertext rather than returning garbage:
+ * a fail-closed decrypt turns a config mistake into a loud, immediate error
+ * instead of corrupt data flowing into a downstream request.
+ */
+declare function decryptSecret(envelope: EncryptedEnvelope, encodedKey: string | undefined | null): Promise<string>;
+/** Round-trip helper for tests and one-shot migrations. */
+declare function roundTripSecret(plaintext: string, encodedKey: string): Promise<string>;
+export { AesGcmKeyError, decryptSecret, encryptSecret, roundTripSecret, IV_BYTES, KEY_BYTES };
+export type { EncryptedEnvelope };
+//# sourceMappingURL=aes-gcm.d.ts.map

package/dist/aes-gcm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes-gcm.d.ts","sourceRoot":"","sources":["../src/aes-gcm.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,QAAA,MAAM,SAAS,KAAK,CAAC;AACrB,QAAA,MAAM,QAAQ,KAAK,CAAC;AAEpB,cAAM,cAAe,SAAQ,KAAK;gBACpB,OAAO,EAAE,MAAM;CAI5B;AAsBD,UAAU,iBAAiB;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;;GAKG;AACH,iBAAe,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,iBAAiB,CAAC,CASjH;AAED;;;;;;GAMG;AACH,iBAAe,aAAa,CAAC,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAMhH;AAED,2DAA2D;AAC3D,iBAAe,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGrF;AAED,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AAC9F,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/aes-gcm.js

@@ -0,0 +1,78 @@
+import { base64ToBytes, bytesToBase64 } from '@rexezuge/shared';
+/**
+ * AES-GCM envelope for values that must be recoverable.
+ *
+ * Converged from the seven drifted copies of `backend-data/crypto/aes-gcm.ts`
+ * (AWS, CalDAV, Durable-DAV, Edge-Git, Edge-Sonic, Mail-Meow, Mail-Otter).
+ * Durable-DAV's is the canonical shape; names are de-scoped from
+ * "replication" because every repo that encrypts a secret — replication remote
+ * passwords, SES credentials, OAuth client secrets — has the same problem.
+ *
+ * Key material is base64 of exactly 32 bytes. A missing or wrong-sized key
+ * throws rather than returning plaintext: the alternative — a helper that
+ * quietly passes the value through when it cannot encrypt — would store the
+ * secret in the clear on exactly the deployments that forgot to configure a
+ * key, and nothing would report it.
+ */
+const KEY_BYTES = 32;
+const IV_BYTES = 12;
+class AesGcmKeyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AesGcmKeyError';
+    }
+}
+async function importKey(encodedKey) {
+    if (typeof encodedKey !== 'string' || encodedKey.trim() === '') {
+        throw new AesGcmKeyError('Encryption key is not configured; the secret cannot be stored');
+    }
+    let raw;
+    try {
+        raw = base64ToBytes(encodedKey.trim());
+    }
+    catch {
+        throw new AesGcmKeyError('Encryption key is not valid base64');
+    }
+    if (raw.byteLength !== KEY_BYTES) {
+        throw new AesGcmKeyError(`Encryption key must decode to ${KEY_BYTES} bytes, got ${raw.byteLength}`);
+    }
+    try {
+        return await crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
+    }
+    catch {
+        throw new AesGcmKeyError('Encryption key could not be imported as an AES-GCM key');
+    }
+}
+/**
+ * Encrypt one secret. The IV is random per call and returned alongside the
+ * ciphertext so the caller can store the pair — reusing an IV under one key
+ * destroys GCM's security guarantees outright, which is why it is not
+ * internal to the ciphertext.
+ */
+async function encryptSecret(plaintext, encodedKey) {
+    const key = await importKey(encodedKey);
+    const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+    const sealed = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: iv }, key, new TextEncoder().encode(plaintext));
+    return { ciphertext: bytesToBase64(new Uint8Array(sealed)), iv: bytesToBase64(iv) };
+}
+/**
+ * Decrypt one envelope.
+ *
+ * Throws on a wrong key or tampered ciphertext rather than returning garbage:
+ * a fail-closed decrypt turns a config mistake into a loud, immediate error
+ * instead of corrupt data flowing into a downstream request.
+ */
+async function decryptSecret(envelope, encodedKey) {
+    const key = await importKey(encodedKey);
+    const iv = base64ToBytes(envelope.iv);
+    const ciphertext = base64ToBytes(envelope.ciphertext);
+    const opened = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: iv }, key, ciphertext);
+    return new TextDecoder().decode(opened);
+}
+/** Round-trip helper for tests and one-shot migrations. */
+async function roundTripSecret(plaintext, encodedKey) {
+    const envelope = await encryptSecret(plaintext, encodedKey);
+    return decryptSecret(envelope, encodedKey);
+}
+export { AesGcmKeyError, decryptSecret, encryptSecret, roundTripSecret, IV_BYTES, KEY_BYTES };
+//# sourceMappingURL=aes-gcm.js.map

package/dist/aes-gcm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes-gcm.js","sourceRoot":"","sources":["../src/aes-gcm.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { BaseDAO, assertSqlIdentifier } from './BaseDAO';
+export { isD1ErrorRetryable, RETRYABLE_PATTERNS, NON_RETRYABLE_PATTERNS } from './D1ErrorClassifier';
+export { isMissingSchemaError, MISSING_SCHEMA_PATTERN } from './isMissingSchemaError';
+export { executableStatements, isExecutable, splitSql } from './splitSql';
+export { backoffMs, D1_RETRY_DEFAULTS, executeWithRetry, sleep } from './D1Retry';
+export type { D1RetryOptions } from './D1Retry';
+export type { D1PreparedStatement, D1Queryable, D1Result } from './D1Types';
+export { AesGcmKeyError, decryptSecret, encryptSecret, roundTripSecret, IV_BYTES, KEY_BYTES } from './aes-gcm';
+export type { EncryptedEnvelope } from './aes-gcm';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACrG,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAClF,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC/G,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { BaseDAO, assertSqlIdentifier } from './BaseDAO';
+export { isD1ErrorRetryable, RETRYABLE_PATTERNS, NON_RETRYABLE_PATTERNS } from './D1ErrorClassifier';
+export { isMissingSchemaError, MISSING_SCHEMA_PATTERN } from './isMissingSchemaError';
+export { executableStatements, isExecutable, splitSql } from './splitSql';
+export { backoffMs, D1_RETRY_DEFAULTS, executeWithRetry, sleep } from './D1Retry';
+export { AesGcmKeyError, decryptSecret, encryptSecret, roundTripSecret, IV_BYTES, KEY_BYTES } from './aes-gcm';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACrG,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAGlF,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC"}

package/dist/isMissingSchemaError.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Distinguishes "the table or column isn't there" from every other way a SQL
+ * statement can fail.
+ *
+ * Provenance: `shared/src/utils/SqlSchemaError.ts` in Durable-DAV (re-exported
+ * from `backend-data`), Byte-comparable copies in Edge-Git, Edge-Sonic and
+ * ChordDHT-Tracker. Durable-DAV's own note is the canonical home decision: both
+ * SQL surfaces the family uses (D1 and DO SQLite) report a missing relation the
+ * same way, so the predicate lives below the layers that degrade on it —
+ * in this kit, that layer is `d1`.
+ *
+ * The rule it exists to enforce is fail-closed: a caller may degrade to `[]` or
+ * a fallback query **only** on `true` here, and must rethrow everything else.
+ * Catching broadly is how "this resource has no dead properties" comes to mean
+ * "the database is corrupt" — a silent data-loss report, which is worse than an
+ * error.
+ */
+declare const MISSING_SCHEMA_PATTERN: RegExp;
+declare function isMissingSchemaError(error: unknown): boolean;
+export { isMissingSchemaError, MISSING_SCHEMA_PATTERN };
+//# sourceMappingURL=isMissingSchemaError.d.ts.map

package/dist/isMissingSchemaError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMissingSchemaError.d.ts","sourceRoot":"","sources":["../src/isMissingSchemaError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,sBAAsB,QAAwC,CAAC;AAErE,iBAAS,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKrD;AAED,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/isMissingSchemaError.js

@@ -0,0 +1,27 @@
+/**
+ * Distinguishes "the table or column isn't there" from every other way a SQL
+ * statement can fail.
+ *
+ * Provenance: `shared/src/utils/SqlSchemaError.ts` in Durable-DAV (re-exported
+ * from `backend-data`), Byte-comparable copies in Edge-Git, Edge-Sonic and
+ * ChordDHT-Tracker. Durable-DAV's own note is the canonical home decision: both
+ * SQL surfaces the family uses (D1 and DO SQLite) report a missing relation the
+ * same way, so the predicate lives below the layers that degrade on it —
+ * in this kit, that layer is `d1`.
+ *
+ * The rule it exists to enforce is fail-closed: a caller may degrade to `[]` or
+ * a fallback query **only** on `true` here, and must rethrow everything else.
+ * Catching broadly is how "this resource has no dead properties" comes to mean
+ * "the database is corrupt" — a silent data-loss report, which is worse than an
+ * error.
+ */
+const MISSING_SCHEMA_PATTERN = /no\s+such\s+(?:table|column|index)/i;
+function isMissingSchemaError(error) {
+    if (error instanceof Error)
+        return MISSING_SCHEMA_PATTERN.test(error.message);
+    // A thrown string is legal; anything else (a number, an object, `undefined`)
+    // carries no message to match against.
+    return typeof error === 'string' && MISSING_SCHEMA_PATTERN.test(error);
+}
+export { isMissingSchemaError, MISSING_SCHEMA_PATTERN };
+//# sourceMappingURL=isMissingSchemaError.js.map

package/dist/isMissingSchemaError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMissingSchemaError.js","sourceRoot":"","sources":["../src/isMissingSchemaError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,sBAAsB,GAAG,qCAAqC,CAAC;AAErE,SAAS,oBAAoB,CAAC,KAAc;IAC1C,IAAI,KAAK,YAAY,KAAK;QAAE,OAAO,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC9E,6EAA6E;IAC7E,uCAAuC;IACvC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACzE,CAAC;AAED,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/splitSql.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Minimal SQL statement splitter for SQLite migration files.
+ *
+ * Provenance: `test/integration/helpers/migrations.ts`, byte-near-identical in
+ * six consumer repos, ported here verbatim because its comment-level history is
+ * the specification for the edge cases (`''` escapes, block comments, trigger
+ * bodies with semicolons). The kit keeps one copy: `@rexezuge/tooling`'s
+ * integration helper and `@rexezuge/identity`'s migration applier both delegate
+ * to this module, so the splitter cannot drift between them.
+ *
+ * Handles: single/double/backtick quoted strings (incl. `''` escapes), `--`
+ * line comments, block comments. Semicolons inside strings or comments do not
+ * split. Statements come back trimmed, without the terminating semicolon, and
+ * with their leading comments attached — use `executableStatements` to drop
+ * comment-only runs before sending anything to D1.
+ *
+ * Trigger-aware: `CREATE TRIGGER ... BEGIN ...; ... END;` bodies contain
+ * semicolons that must not split. The splitter tracks the outermost BEGIN/END
+ * depth after a CREATE TRIGGER header and only splits on the terminating
+ * semicolon after the final END.
+ */
+declare function splitSql(sql: string): string[];
+/**
+ * Whether a statement is executable SQL rather than a comment.
+ *
+ * Checked after the split, because the splitter has to keep comments attached to
+ * the statement they sit above — dropping them there would change what an error
+ * message quotes.
+ */
+declare function isExecutable(statement: string): boolean;
+/**
+ * The executable statements of one migration file, in order: split first, then
+ * filtered. A splitter that dropped comments itself would also drop the ones a
+ * migration keeps beside the statement they describe.
+ */
+declare function executableStatements(sql: string): string[];
+export { executableStatements, isExecutable, splitSql };
+//# sourceMappingURL=splitSql.d.ts.map

package/dist/splitSql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitSql.d.ts","sourceRoot":"","sources":["../src/splitSql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAsHvC;AAED;;;;;;GAMG;AACH,iBAAS,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAKhD;AAED;;;;GAIG;AACH,iBAAS,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAEnD;AAED,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC"}

package/dist/splitSql.js

@@ -0,0 +1,168 @@
+/**
+ * Minimal SQL statement splitter for SQLite migration files.
+ *
+ * Provenance: `test/integration/helpers/migrations.ts`, byte-near-identical in
+ * six consumer repos, ported here verbatim because its comment-level history is
+ * the specification for the edge cases (`''` escapes, block comments, trigger
+ * bodies with semicolons). The kit keeps one copy: `@rexezuge/tooling`'s
+ * integration helper and `@rexezuge/identity`'s migration applier both delegate
+ * to this module, so the splitter cannot drift between them.
+ *
+ * Handles: single/double/backtick quoted strings (incl. `''` escapes), `--`
+ * line comments, block comments. Semicolons inside strings or comments do not
+ * split. Statements come back trimmed, without the terminating semicolon, and
+ * with their leading comments attached — use `executableStatements` to drop
+ * comment-only runs before sending anything to D1.
+ *
+ * Trigger-aware: `CREATE TRIGGER ... BEGIN ...; ... END;` bodies contain
+ * semicolons that must not split. The splitter tracks the outermost BEGIN/END
+ * depth after a CREATE TRIGGER header and only splits on the terminating
+ * semicolon after the final END.
+ */
+function splitSql(sql) {
+    const statements = [];
+    let current = '';
+    let inString = false;
+    let stringChar = '';
+    let inLineComment = false;
+    let inBlockComment = false;
+    let inTrigger = false;
+    let triggerDepth = 0;
+    let word = '';
+    const recentKeywords = [];
+    const flushWord = () => {
+        if (word.length === 0)
+            return;
+        const upper = word.toUpperCase();
+        word = '';
+        recentKeywords.push(upper);
+        if (recentKeywords.length > 6)
+            recentKeywords.shift();
+        // `CREATE [TEMP|TEMPORARY] TRIGGER` opens a body; a table merely named
+        // "trigger" (`CREATE TABLE trigger`) must not. The word before TRIGGER
+        // disambiguates.
+        if (upper === 'TRIGGER' && ['CREATE', 'TEMP', 'TEMPORARY'].includes(recentKeywords.at(-2) ?? '')) {
+            inTrigger = true;
+            triggerDepth = 0;
+        }
+        else if (inTrigger && upper === 'BEGIN') {
+            triggerDepth += 1;
+        }
+        else if (inTrigger && upper === 'END') {
+            triggerDepth -= 1;
+            if (triggerDepth <= 0) {
+                inTrigger = false;
+                triggerDepth = 0;
+            }
+        }
+    };
+    let index = 0;
+    while (index < sql.length) {
+        const char = sql[index];
+        const next = sql[index + 1] ?? '';
+        if (inLineComment) {
+            current += char;
+            if (char === '\n')
+                inLineComment = false;
+            index += 1;
+            continue;
+        }
+        if (inBlockComment) {
+            current += char;
+            if (char === '*' && next === '/') {
+                current += next;
+                index += 2;
+                inBlockComment = false;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (inString) {
+            current += char;
+            if (char === stringChar) {
+                // SQL escapes a quote by doubling it ('it''s'); do not end the string.
+                if (sql[index + 1] === stringChar) {
+                    current += sql[index + 1];
+                    index += 2;
+                    continue;
+                }
+                if (sql[index - 1] !== '\\')
+                    inString = false;
+            }
+            index += 1;
+            continue;
+        }
+        // Buffer word characters for CREATE TRIGGER / BEGIN / END tracking.
+        // Any other character ends the current word.
+        if (/[\w$]/.test(char)) {
+            word += char;
+            current += char;
+            index += 1;
+            continue;
+        }
+        flushWord();
+        if (char === '-' && next === '-') {
+            inLineComment = true;
+            current += char;
+            index += 1;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            inBlockComment = true;
+            current += char;
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === '"' || char === '`') {
+            inString = true;
+            stringChar = char;
+            current += char;
+            index += 1;
+            continue;
+        }
+        if (char === ';') {
+            // Semicolons inside a trigger body do not terminate the statement.
+            if (inTrigger) {
+                current += char;
+                index += 1;
+                continue;
+            }
+            const trimmed = current.trim();
+            if (trimmed.length > 0)
+                statements.push(trimmed);
+            current = '';
+            index += 1;
+            continue;
+        }
+        current += char;
+        index += 1;
+    }
+    const trimmed = current.trim();
+    if (trimmed.length > 0)
+        statements.push(trimmed);
+    return statements;
+}
+/**
+ * Whether a statement is executable SQL rather than a comment.
+ *
+ * Checked after the split, because the splitter has to keep comments attached to
+ * the statement they sit above — dropping them there would change what an error
+ * message quotes.
+ */
+function isExecutable(statement) {
+    const withoutComments = statement
+        .replaceAll(/--[^\n]*/g, '')
+        .replaceAll(/\/\*[\s\S]*?\*\//g, '');
+    return withoutComments.trim().length > 0;
+}
+/**
+ * The executable statements of one migration file, in order: split first, then
+ * filtered. A splitter that dropped comments itself would also drop the ones a
+ * migration keeps beside the statement they describe.
+ */
+function executableStatements(sql) {
+    return splitSql(sql).filter(isExecutable);
+}
+export { executableStatements, isExecutable, splitSql };
+//# sourceMappingURL=splitSql.js.map

package/dist/splitSql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitSql.js","sourceRoot":"","sources":["../src/splitSql.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@rexezuge/d1",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rexezuge-CloudflareWorkers/SDK.git",
+    "directory": "packages/d1"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@rexezuge/shared": "1.0.0",
+    "@rexezuge/errors": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "26.6.4",
+    "typescript": "6.0.3",
+    "vitest": "4.1.11"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.