payweave 0.0.0

package/dist/db/sqlite/index.js

@@ -0,0 +1,750 @@
+import { applyMigrations, planMigrations } from '../../chunk-QJHXDZYC.js';
+import { PW_ACTIVE_SUBSCRIPTION_STATUSES, PW_TABLES, DEFAULT_STALE_CLAIM_AFTER_MS } from '../../chunk-NV3MZF7L.js';
+import { currentPeriod } from '../../chunk-4R5OGOCC.js';
+import { PayweaveConfigError, PayweaveNotFoundError, PayweaveError, PayweaveValidationError } from '../../chunk-HTRGMZFH.js';
+import { randomInt } from 'crypto';
+
+// src/db/sqlite/errors.ts
+var DRIVER_PACKAGE = {
+  "better-sqlite3": "better-sqlite3",
+  libsql: "@libsql/client"
+};
+function installHintError(driver, url, cause) {
+  const pkg = DRIVER_PACKAGE[driver];
+  return new PayweaveConfigError(
+    `payweave/db/sqlite: opening ${JSON.stringify(url)} requires the "${pkg}" package, which is not installed (it is an optional peerDependency of "payweave"). Run \`npm install ${pkg}\` (or your package manager's equivalent) and try again.`,
+    { cause }
+  );
+}
+function isConstraintViolation(error) {
+  const code = error?.code;
+  return typeof code === "string" && code.startsWith("SQLITE_CONSTRAINT");
+}
+function wrapDriverError(error, message) {
+  if (error instanceof PayweaveError) return error;
+  if (isConstraintViolation(error)) {
+    return new PayweaveValidationError(message, { cause: error });
+  }
+  return new PayweaveError(message, { cause: error, isRetryable: false });
+}
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(timeMs, len) {
+  if (!Number.isSafeInteger(timeMs) || timeMs < 0) {
+    throw new RangeError(`ulid: time must be a non-negative safe integer \u2014 got ${timeMs}`);
+  }
+  let remaining = timeMs;
+  let out = "";
+  for (let i = 0; i < len; i++) {
+    const mod = remaining % ENCODING_LEN;
+    out = ENCODING.charAt(mod) + out;
+    remaining = Math.floor(remaining / ENCODING_LEN);
+  }
+  return out;
+}
+function encodeRandom(len) {
+  let out = "";
+  for (let i = 0; i < len; i++) {
+    out += ENCODING.charAt(randomInt(0, ENCODING_LEN));
+  }
+  return out;
+}
+function ulid(timeMs = Date.now()) {
+  return encodeTime(timeMs, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+function generatePwId(timeMs = Date.now()) {
+  return `pwv_${ulid(timeMs)}`;
+}
+
+// src/db/sqlite/migrations-executor.ts
+var SqliteMigrationExecutor = class _SqliteMigrationExecutor {
+  #runner;
+  constructor(runner) {
+    this.#runner = runner;
+  }
+  async query(sql, params = []) {
+    const { rows } = await this.#runner.execute(sql, params);
+    return { rows };
+  }
+  async transaction(fn) {
+    return this.#runner.transaction((tx) => fn(new _SqliteMigrationExecutor(tx)));
+  }
+};
+
+// src/db/sqlite/rows.ts
+function requireColumn(row, column) {
+  if (!(column in row)) {
+    throw new Error(`sqlite adapter: row is missing expected column "${column}"`);
+  }
+  return row[column];
+}
+function str(row, column) {
+  const value = requireColumn(row, column);
+  if (typeof value !== "string") {
+    throw new Error(`sqlite adapter: expected column "${column}" to be a string, got ${typeof value}`);
+  }
+  return value;
+}
+function nullableStr(row, column) {
+  const value = requireColumn(row, column);
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "string") {
+    throw new Error(`sqlite adapter: expected column "${column}" to be a string or null, got ${typeof value}`);
+  }
+  return value;
+}
+function num(row, column) {
+  const value = requireColumn(row, column);
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value !== "number") {
+    throw new Error(`sqlite adapter: expected column "${column}" to be a number, got ${typeof value}`);
+  }
+  return value;
+}
+function bool(row, column) {
+  return num(row, column) !== 0;
+}
+function dateOf(row, column) {
+  return new Date(num(row, column));
+}
+function json(row, column) {
+  return JSON.parse(str(row, column));
+}
+var encodeDate = (date) => date.getTime();
+var encodeBool = (value) => value ? 1 : 0;
+var encodeJson = (value) => JSON.stringify(value);
+function rowToCustomer(row) {
+  return {
+    id: str(row, "id"),
+    externalId: str(row, "external_id"),
+    providerIds: json(row, "provider_ids"),
+    email: nullableStr(row, "email"),
+    createdAt: dateOf(row, "created_at"),
+    updatedAt: dateOf(row, "updated_at")
+  };
+}
+function rowToPlanVersion(row) {
+  return {
+    id: str(row, "id"),
+    planId: str(row, "plan_id"),
+    version: num(row, "version"),
+    group: str(row, "group"),
+    isDefault: bool(row, "is_default"),
+    name: nullableStr(row, "name"),
+    priceMinor: (() => {
+      const v = requireColumn(row, "price_minor");
+      return v === null ? null : num(row, "price_minor");
+    })(),
+    priceCurrency: nullableStr(row, "price_currency"),
+    priceInterval: nullableStr(row, "price_interval"),
+    features: json(row, "features"),
+    providerRefs: json(row, "provider_refs"),
+    pushedAt: dateOf(row, "pushed_at")
+  };
+}
+function rowToSubscription(row) {
+  return {
+    id: str(row, "id"),
+    customerId: str(row, "customer_id"),
+    planId: str(row, "plan_id"),
+    planVersion: num(row, "plan_version"),
+    group: str(row, "group"),
+    status: str(row, "status"),
+    provider: nullableStr(row, "provider"),
+    providerSubscriptionRef: nullableStr(row, "provider_subscription_ref"),
+    currentPeriodStart: dateOf(row, "current_period_start"),
+    currentPeriodEnd: dateOf(row, "current_period_end"),
+    cancelAtPeriodEnd: bool(row, "cancel_at_period_end"),
+    createdAt: dateOf(row, "created_at"),
+    updatedAt: dateOf(row, "updated_at")
+  };
+}
+function rowToFeatureBalance(row) {
+  return {
+    id: str(row, "id"),
+    customerId: str(row, "customer_id"),
+    featureId: str(row, "feature_id"),
+    group: str(row, "group"),
+    used: num(row, "used"),
+    limit: num(row, "limit"),
+    resetInterval: str(row, "reset_interval"),
+    anchor: dateOf(row, "anchor"),
+    periodStart: dateOf(row, "period_start"),
+    periodEnd: dateOf(row, "period_end"),
+    planId: str(row, "plan_id"),
+    planVersion: num(row, "plan_version"),
+    updatedAt: dateOf(row, "updated_at")
+  };
+}
+
+// src/db/sqlite/adapter.ts
+var ACTIVE_STATUS_PLACEHOLDERS = PW_ACTIVE_SUBSCRIPTION_STATUSES.map(() => "?").join(", ");
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    );
+    return `{${entries.map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+var planContent = (p) => ({
+  group: p.group,
+  isDefault: p.isDefault,
+  name: p.name,
+  priceMinor: p.priceMinor,
+  priceCurrency: p.priceCurrency,
+  priceInterval: p.priceInterval,
+  features: p.features,
+  providerRefs: p.providerRefs
+});
+function planContentEquals(active, input) {
+  return stableStringify(planContent(active)) === stableStringify(planContent(input));
+}
+var SUBSCRIPTION_PATCH_FIELDS = [
+  { key: "planId", column: "plan_id", encode: (v) => v },
+  { key: "planVersion", column: "plan_version", encode: (v) => v },
+  { key: "status", column: "status", encode: (v) => v },
+  { key: "provider", column: "provider", encode: (v) => v },
+  { key: "providerSubscriptionRef", column: "provider_subscription_ref", encode: (v) => v },
+  { key: "currentPeriodStart", column: "current_period_start", encode: (v) => encodeDate(v) },
+  { key: "currentPeriodEnd", column: "current_period_end", encode: (v) => encodeDate(v) },
+  { key: "cancelAtPeriodEnd", column: "cancel_at_period_end", encode: (v) => encodeBool(v) }
+];
+function buildAdapter(runner) {
+  return {
+    dialect: "sqlite",
+    customers: {
+      getByExternalId: (externalId) => customersGetByExternalId(runner, externalId),
+      upsert: (input) => customersUpsert(runner, input),
+      linkProviderRef: (externalId, provider, ref) => customersLinkProviderRef(runner, externalId, provider, ref)
+    },
+    plans: {
+      getActiveVersion: (planId) => plansGetActiveVersion(runner, planId),
+      listActive: () => plansListActive(runner),
+      pushVersion: (plan) => plansPushVersion(runner, plan)
+    },
+    subscriptions: {
+      getActive: (customerId, group) => subscriptionsGetActive(runner, customerId, group),
+      create: (input) => subscriptionsCreate(runner, input),
+      update: (id, patch) => subscriptionsUpdate(runner, id, patch)
+    },
+    balances: {
+      get: (customerId, featureId, group) => balancesGet(runner, customerId, featureId, group),
+      consume: (input) => balancesConsume(runner, input),
+      resetTo: (customerId, featureId, group, init) => balancesResetTo(runner, customerId, featureId, group, init)
+    },
+    webhookEvents: {
+      claim: (dedupeKey, meta) => webhookEventsClaim(runner, dedupeKey, meta),
+      markApplied: (dedupeKey) => webhookEventsMarkApplied(runner, dedupeKey)
+    },
+    migrations: {
+      status: () => planMigrations(new SqliteMigrationExecutor(runner), "sqlite"),
+      apply: () => applyMigrations(new SqliteMigrationExecutor(runner), "sqlite")
+    },
+    transaction: (fn) => runner.transaction((tx) => fn(buildAdapter(tx)))
+  };
+}
+async function customersGetByExternalId(runner, externalId) {
+  const { rows } = await runner.execute(
+    `SELECT * FROM ${PW_TABLES.customers} WHERE external_id = ?`,
+    [externalId]
+  );
+  const row = rows[0];
+  return row ? rowToCustomer(row) : null;
+}
+async function customersUpsert(runner, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const { rows } = await runner.execute(
+      `INSERT INTO ${PW_TABLES.customers} (id, external_id, provider_ids, email, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(external_id) DO UPDATE SET
+         email = COALESCE(excluded.email, ${PW_TABLES.customers}.email),
+         updated_at = excluded.updated_at
+       RETURNING *`,
+      [id, input.externalId, encodeJson({}), input.email ?? null, encodeDate(now), encodeDate(now)]
+    );
+    const row = rows[0];
+    if (!row) throw new Error("sqlite adapter: customers.upsert returned no row");
+    return rowToCustomer(row);
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/sqlite: customers.upsert(${JSON.stringify(input.externalId)}) failed.`
+    );
+  }
+}
+async function customersLinkProviderRef(runner, externalId, provider, ref) {
+  await runner.transaction(async (tx) => {
+    const { rows } = await tx.execute(
+      `SELECT * FROM ${PW_TABLES.customers} WHERE external_id = ?`,
+      [externalId]
+    );
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/sqlite: customers.linkProviderRef: no customer with externalId ${JSON.stringify(externalId)}.`
+      );
+    }
+    const customer = rowToCustomer(row);
+    const providerIds = { ...customer.providerIds, [provider]: ref };
+    await tx.execute(
+      `UPDATE ${PW_TABLES.customers} SET provider_ids = ?, updated_at = ? WHERE external_id = ?`,
+      [encodeJson(providerIds), encodeDate(/* @__PURE__ */ new Date()), externalId]
+    );
+  });
+}
+async function plansGetActiveVersion(runner, planId) {
+  const { rows } = await runner.execute(
+    `SELECT * FROM ${PW_TABLES.plans} WHERE plan_id = ? ORDER BY version DESC LIMIT 1`,
+    [planId]
+  );
+  const row = rows[0];
+  return row ? rowToPlanVersion(row) : null;
+}
+async function plansListActive(runner) {
+  const { rows } = await runner.execute(
+    `SELECT p.* FROM ${PW_TABLES.plans} p
+     INNER JOIN (
+       SELECT plan_id, MAX(version) AS version FROM ${PW_TABLES.plans} GROUP BY plan_id
+     ) latest ON latest.plan_id = p.plan_id AND latest.version = p.version`
+  );
+  return rows.map(rowToPlanVersion);
+}
+async function plansPushVersion(runner, plan) {
+  return runner.transaction(async (tx) => {
+    const { rows } = await tx.execute(
+      `SELECT * FROM ${PW_TABLES.plans} WHERE plan_id = ? ORDER BY version DESC LIMIT 1`,
+      [plan.planId]
+    );
+    const activeRow = rows[0];
+    const active = activeRow ? rowToPlanVersion(activeRow) : null;
+    if (active && planContentEquals(active, plan)) {
+      return active;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const id = generatePwId(now.getTime());
+    const nextVersion = (active?.version ?? 0) + 1;
+    const { rows: inserted } = await tx.execute(
+      `INSERT INTO ${PW_TABLES.plans}
+         (id, plan_id, version, "group", is_default, name, price_minor, price_currency, price_interval, features, provider_refs, pushed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`,
+      [
+        id,
+        plan.planId,
+        nextVersion,
+        plan.group,
+        encodeBool(plan.isDefault),
+        plan.name,
+        plan.priceMinor,
+        plan.priceCurrency,
+        plan.priceInterval,
+        encodeJson(plan.features),
+        encodeJson(plan.providerRefs),
+        encodeDate(now)
+      ]
+    );
+    const row = inserted[0];
+    if (!row) throw new Error("sqlite adapter: plans.pushVersion returned no row");
+    return rowToPlanVersion(row);
+  });
+}
+async function subscriptionsGetActive(runner, customerId, group) {
+  const { rows } = await runner.execute(
+    `SELECT * FROM ${PW_TABLES.subscriptions}
+     WHERE customer_id = ? AND "group" = ? AND status IN (${ACTIVE_STATUS_PLACEHOLDERS})`,
+    [customerId, group, ...PW_ACTIVE_SUBSCRIPTION_STATUSES]
+  );
+  const row = rows[0];
+  return row ? rowToSubscription(row) : null;
+}
+async function subscriptionsCreate(runner, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const { rows } = await runner.execute(
+      `INSERT INTO ${PW_TABLES.subscriptions}
+        (id, customer_id, plan_id, plan_version, "group", status, provider, provider_subscription_ref,
+         current_period_start, current_period_end, cancel_at_period_end, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`,
+      [
+        id,
+        input.customerId,
+        input.planId,
+        input.planVersion,
+        input.group,
+        input.status,
+        input.provider,
+        input.providerSubscriptionRef,
+        encodeDate(input.currentPeriodStart),
+        encodeDate(input.currentPeriodEnd),
+        encodeBool(input.cancelAtPeriodEnd),
+        encodeDate(now),
+        encodeDate(now)
+      ]
+    );
+    const row = rows[0];
+    if (!row) throw new Error("sqlite adapter: subscriptions.create returned no row");
+    return rowToSubscription(row);
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/sqlite: subscriptions.create for customer ${JSON.stringify(input.customerId)} group ${JSON.stringify(input.group)} violated a uniqueness rule (an active-set subscription already exists for this customer/group, or another constraint failed).`
+    );
+  }
+}
+async function subscriptionsUpdate(runner, id, patch) {
+  const sets = [];
+  const params = [];
+  const patchRecord = patch;
+  for (const field of SUBSCRIPTION_PATCH_FIELDS) {
+    if (!(field.key in patch) || patchRecord[field.key] === void 0) continue;
+    sets.push(`${field.column} = ?`);
+    params.push(field.encode(patchRecord[field.key]));
+  }
+  sets.push("updated_at = ?");
+  params.push(encodeDate(/* @__PURE__ */ new Date()));
+  params.push(id);
+  try {
+    const { rows } = await runner.execute(
+      `UPDATE ${PW_TABLES.subscriptions} SET ${sets.join(", ")} WHERE id = ? RETURNING *`,
+      params
+    );
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/sqlite: subscriptions.update: no subscription with id ${JSON.stringify(id)}.`
+      );
+    }
+    return rowToSubscription(row);
+  } catch (error) {
+    if (error instanceof PayweaveNotFoundError) throw error;
+    throw wrapDriverError(error, `payweave/db/sqlite: subscriptions.update(${JSON.stringify(id)}) failed.`);
+  }
+}
+async function balancesGet(runner, customerId, featureId, group) {
+  const { rows } = await runner.execute(
+    `SELECT * FROM ${PW_TABLES.featureBalances} WHERE customer_id = ? AND feature_id = ? AND "group" = ?`,
+    [customerId, featureId, group]
+  );
+  const row = rows[0];
+  return row ? rowToFeatureBalance(row) : null;
+}
+async function balancesConsume(runner, input) {
+  return runner.transaction(async (tx) => {
+    const { rows } = await tx.execute(
+      `SELECT * FROM ${PW_TABLES.featureBalances} WHERE customer_id = ? AND feature_id = ? AND "group" = ?`,
+      [input.customerId, input.featureId, input.group]
+    );
+    const existingRow = rows[0];
+    const nowMs = input.now.getTime();
+    if (!existingRow) {
+      const period2 = currentPeriod(input.init.anchor.getTime(), input.init.resetInterval, nowMs);
+      const remaining2 = input.init.limit;
+      const applied2 = input.conditional !== true || remaining2 >= input.amount;
+      const used = applied2 ? input.amount : 0;
+      const id = generatePwId(nowMs);
+      const { rows: inserted } = await tx.execute(
+        `INSERT INTO ${PW_TABLES.featureBalances}
+           (id, customer_id, feature_id, "group", used, "limit", reset_interval, anchor, period_start, period_end, plan_id, plan_version, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         RETURNING *`,
+        [
+          id,
+          input.customerId,
+          input.featureId,
+          input.group,
+          used,
+          input.init.limit,
+          input.init.resetInterval,
+          encodeDate(input.init.anchor),
+          period2.start,
+          period2.end,
+          input.init.planId,
+          input.init.planVersion,
+          encodeDate(input.now)
+        ]
+      );
+      const row = inserted[0];
+      if (!row) throw new Error("sqlite adapter: balances.consume (create) returned no row");
+      return { ...rowToFeatureBalance(row), applied: applied2 };
+    }
+    const existing = rowToFeatureBalance(existingRow);
+    const resetDue = nowMs >= existing.periodEnd.getTime();
+    const baseUsed = resetDue ? 0 : existing.used;
+    const period = resetDue ? currentPeriod(existing.anchor.getTime(), existing.resetInterval, nowMs) : { start: existing.periodStart.getTime(), end: existing.periodEnd.getTime() };
+    const remaining = existing.limit - baseUsed;
+    const applied = input.conditional !== true || remaining >= input.amount;
+    if (!applied && !resetDue) {
+      return { ...existing, applied: false };
+    }
+    const finalUsed = applied ? baseUsed + input.amount : baseUsed;
+    const { rows: updatedRows } = await tx.execute(
+      `UPDATE ${PW_TABLES.featureBalances}
+       SET used = ?, period_start = ?, period_end = ?, updated_at = ?
+       WHERE id = ?
+       RETURNING *`,
+      [finalUsed, period.start, period.end, encodeDate(input.now), existing.id]
+    );
+    const updatedRow = updatedRows[0];
+    if (!updatedRow) throw new Error("sqlite adapter: balances.consume (update) returned no row");
+    return { ...rowToFeatureBalance(updatedRow), applied };
+  });
+}
+async function balancesResetTo(runner, customerId, featureId, group, init) {
+  const now = /* @__PURE__ */ new Date();
+  const period = currentPeriod(init.anchor.getTime(), init.resetInterval, now.getTime());
+  const id = generatePwId(now.getTime());
+  await runner.execute(
+    `INSERT INTO ${PW_TABLES.featureBalances}
+       (id, customer_id, feature_id, "group", used, "limit", reset_interval, anchor, period_start, period_end, plan_id, plan_version, updated_at)
+     VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(customer_id, feature_id, "group") DO UPDATE SET
+       used = 0,
+       "limit" = excluded."limit",
+       reset_interval = excluded.reset_interval,
+       anchor = excluded.anchor,
+       period_start = excluded.period_start,
+       period_end = excluded.period_end,
+       plan_id = excluded.plan_id,
+       plan_version = excluded.plan_version,
+       updated_at = excluded.updated_at`,
+    [
+      id,
+      customerId,
+      featureId,
+      group,
+      init.limit,
+      init.resetInterval,
+      encodeDate(init.anchor),
+      period.start,
+      period.end,
+      init.planId,
+      init.planVersion,
+      encodeDate(now)
+    ]
+  );
+}
+async function webhookEventsClaim(runner, dedupeKey, meta) {
+  const staleClaimAfterMs = meta.staleClaimAfterMs ?? DEFAULT_STALE_CLAIM_AFTER_MS;
+  const nowMs = meta.now.getTime();
+  const staleThreshold = nowMs - staleClaimAfterMs;
+  const { rows } = await runner.execute(
+    `INSERT INTO ${PW_TABLES.webhookEvents} (dedupe_key, provider, type, received_at, claimed_at, applied_at)
+     VALUES (?, ?, ?, ?, ?, NULL)
+     ON CONFLICT(dedupe_key) DO UPDATE SET claimed_at = excluded.claimed_at
+     WHERE ${PW_TABLES.webhookEvents}.applied_at IS NULL
+       AND ${PW_TABLES.webhookEvents}.claimed_at <= ?
+     RETURNING dedupe_key`,
+    [dedupeKey, meta.provider, meta.type, nowMs, nowMs, staleThreshold]
+  );
+  return rows.length > 0;
+}
+async function webhookEventsMarkApplied(runner, dedupeKey) {
+  await runner.execute(
+    `UPDATE ${PW_TABLES.webhookEvents} SET applied_at = ? WHERE dedupe_key = ?`,
+    [Date.now(), dedupeKey]
+  );
+}
+
+// src/db/sqlite/drivers/better-sqlite3.ts
+var BetterSqlite3Raw = class {
+  #db;
+  constructor(db) {
+    this.#db = db;
+  }
+  async exec(sql, params = []) {
+    const statement = this.#db.prepare(sql);
+    if (statement.reader) {
+      return { rows: statement.all(...params) };
+    }
+    statement.run(...params);
+    return { rows: [] };
+  }
+};
+function sqliteFileUrlToPath(url) {
+  const withoutScheme = url.slice("file:".length);
+  return withoutScheme.startsWith("//") ? withoutScheme.slice(2) : withoutScheme;
+}
+function openBetterSqlite3(DatabaseCtor, url) {
+  const path = url === ":memory:" ? ":memory:" : url.startsWith("file:") ? sqliteFileUrlToPath(url) : url;
+  const db = new DatabaseCtor(path);
+  if (path !== ":memory:") {
+    db.pragma("journal_mode = WAL");
+    db.pragma("busy_timeout = 5000");
+  }
+  return db;
+}
+
+// src/db/sqlite/drivers/libsql.ts
+var LibsqlRaw = class {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  async exec(sql, params = []) {
+    const result = await this.#client.execute({ sql, args: params });
+    return { rows: result.rows };
+  }
+};
+
+// src/db/sqlite/runner.ts
+var AutoQueueRunner = class {
+  #queue = Promise.resolve();
+  #getDriver;
+  constructor(getDriver) {
+    this.#getDriver = getDriver;
+  }
+  #enqueue(fn) {
+    const result = this.#queue.then(fn);
+    this.#queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  execute(sql, params = []) {
+    return this.#enqueue(async () => {
+      const driver = await this.#getDriver();
+      return driver.exec(sql, params);
+    });
+  }
+  transaction(fn) {
+    return this.#enqueue(async () => {
+      const driver = await this.#getDriver();
+      await driver.exec("BEGIN IMMEDIATE", []);
+      const txRunner = new TransactionRunner(driver);
+      try {
+        const result = await fn(txRunner);
+        await driver.exec("COMMIT", []);
+        return result;
+      } catch (error) {
+        await driver.exec("ROLLBACK", []).catch(() => void 0);
+        throw error;
+      }
+    });
+  }
+};
+var TransactionRunner = class {
+  #driver;
+  constructor(driver) {
+    this.#driver = driver;
+  }
+  execute(sql, params = []) {
+    return this.#driver.exec(sql, params);
+  }
+  // Reentrant: already inside one atomic unit, so nested `transaction()`
+  // calls (e.g. a user's `db.transaction(tx => tx.balances.consume(...))`)
+  // just run inline rather than attempting a nested BEGIN.
+  transaction(fn) {
+    return fn(this);
+  }
+};
+
+// src/db/sqlite/url.ts
+var LIBSQL_URL_SCHEMES = ["libsql://", "wss://", "https://", "http://"];
+function classifySqliteUrl(url) {
+  if (typeof url !== "string" || url.length === 0) {
+    throw new PayweaveConfigError(
+      `payweave/db/sqlite: sqliteAdapter({ url }) requires a non-empty string url \u2014 got ${JSON.stringify(url)}.`
+    );
+  }
+  if (url === ":memory:" || url.startsWith("file:")) {
+    return "better-sqlite3";
+  }
+  if (LIBSQL_URL_SCHEMES.some((scheme) => url.startsWith(scheme))) {
+    return "libsql";
+  }
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(url)) {
+    throw new PayweaveConfigError(
+      `payweave/db/sqlite: unsupported URL scheme in ${JSON.stringify(url)} \u2014 expected ":memory:", "file:...", a bare filesystem path, or a libSQL/Turso URL ("libsql://", "wss://", "https://", "http://").`
+    );
+  }
+  return "better-sqlite3";
+}
+function looksLikeBetterSqlite3(value) {
+  const candidate = value;
+  return typeof candidate.prepare === "function" && typeof candidate.pragma === "function";
+}
+function looksLikeLibsqlClient(value) {
+  const candidate = value;
+  return typeof candidate.execute === "function" && typeof candidate.batch === "function";
+}
+function resolveSqliteInput(input) {
+  if (input === null || typeof input !== "object") {
+    throw new PayweaveConfigError(
+      `payweave/db/sqlite: sqliteAdapter(...) expects { url } (a file:/:memory:/bare-path/libSQL URL), a better-sqlite3 Database instance, or an @libsql/client Client instance \u2014 got ${input === null ? "null" : typeof input}.`
+    );
+  }
+  if ("url" in input) {
+    const url = input.url;
+    if (typeof url !== "string") {
+      throw new PayweaveConfigError(
+        `payweave/db/sqlite: sqliteAdapter({ url }) requires url to be a string \u2014 got ${typeof url}.`
+      );
+    }
+    return { kind: "url", driver: classifySqliteUrl(url), url };
+  }
+  if (looksLikeBetterSqlite3(input)) {
+    return { kind: "better-sqlite3-instance", database: input };
+  }
+  if (looksLikeLibsqlClient(input)) {
+    return { kind: "libsql-instance", client: input };
+  }
+  throw new PayweaveConfigError(
+    "payweave/db/sqlite: sqliteAdapter(...) expects { url } (a file:/:memory:/bare-path/libSQL URL), a better-sqlite3 Database instance (has .prepare()/.pragma()), or an @libsql/client Client instance (has .execute()/.batch()) \u2014 got an object matching none of these shapes."
+  );
+}
+
+// src/db/sqlite/index.ts
+async function openBetterSqlite3Driver(url) {
+  let mod;
+  try {
+    mod = await import('better-sqlite3');
+  } catch (cause) {
+    throw installHintError("better-sqlite3", url, cause);
+  }
+  const database = openBetterSqlite3(mod.default, url);
+  return new BetterSqlite3Raw(database);
+}
+async function openLibsqlDriver(url) {
+  let mod;
+  try {
+    mod = await import('@libsql/client');
+  } catch (cause) {
+    throw installHintError("libsql", url, cause);
+  }
+  const client = mod.createClient({ url });
+  return new LibsqlRaw(client);
+}
+function connect(target) {
+  switch (target.kind) {
+    case "better-sqlite3-instance":
+      return Promise.resolve(new BetterSqlite3Raw(target.database));
+    case "libsql-instance":
+      return Promise.resolve(new LibsqlRaw(target.client));
+    case "url":
+      return target.driver === "better-sqlite3" ? openBetterSqlite3Driver(target.url) : openLibsqlDriver(target.url);
+  }
+}
+function sqliteAdapter(input) {
+  const target = resolveSqliteInput(input);
+  let driverPromise;
+  const getDriver = () => {
+    driverPromise ??= connect(target);
+    return driverPromise;
+  };
+  const runner = new AutoQueueRunner(getDriver);
+  return buildAdapter(runner);
+}
+
+export { sqliteAdapter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map