payweave 0.0.0

package/dist/db/drizzle/index.js

@@ -0,0 +1,1532 @@
+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 { mysqlTable, datetime, varchar, json, bigint, boolean, int, uniqueIndex, char, MySqlDatabase } from 'drizzle-orm/mysql-core';
+import { pgTable, timestamp, text, jsonb, bigint as bigint$1, boolean as boolean$1, integer, uniqueIndex as uniqueIndex$1, PgDatabase } from 'drizzle-orm/pg-core';
+import { sqliteTable, integer as integer$1, text as text$1, uniqueIndex as uniqueIndex$2, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { sql, eq, and } from 'drizzle-orm';
+import { randomInt } from 'crypto';
+
+function detectDrizzleDialect(db, override) {
+  if (override !== void 0) return override;
+  if (db instanceof PgDatabase) return "postgres";
+  if (db instanceof MySqlDatabase) return "mysql";
+  if (db instanceof BaseSQLiteDatabase) return "sqlite";
+  throw new PayweaveConfigError(
+    'payweave/db/drizzle: could not detect the SQL dialect of the given Drizzle instance (expected an instance backed by drizzle-orm/pg-core, drizzle-orm/mysql-core, or drizzle-orm/sqlite-core). Pass it explicitly: drizzleAdapter(db, { dialect: "postgres" | "mysql" | "sqlite" }).'
+  );
+}
+
+// src/db/drizzle/errors.ts
+function constraintCode(error) {
+  const direct = error?.code;
+  if (typeof direct === "string") return direct;
+  const cause = error?.cause;
+  const nested = cause?.code;
+  return typeof nested === "string" ? nested : void 0;
+}
+function isConstraintViolation(error) {
+  const code = constraintCode(error);
+  if (code === void 0) return false;
+  return code.startsWith("SQLITE_CONSTRAINT") || // better-sqlite3 / @libsql/client
+  code === "23505" || // postgres unique_violation
+  code === "23P01" || // postgres exclusion_violation
+  code === "ER_DUP_ENTRY";
+}
+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/drizzle/plan-content.ts
+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 ACTIVE_STATUS_SQL_LIST = sql.raw(
+  PW_ACTIVE_SUBSCRIPTION_STATUSES.map((s) => `'${s}'`).join(", ")
+);
+var utf8mb4Bin = { charSet: "utf8mb4", collate: "utf8mb4_bin" };
+var pwCustomers = mysqlTable(PW_TABLES.customers, {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  externalId: varchar("external_id", { length: 255, ...utf8mb4Bin }).notNull().unique(),
+  providerIds: json("provider_ids").$type().notNull(),
+  email: varchar("email", { length: 255 }),
+  createdAt: datetime("created_at", { fsp: 3 }).notNull(),
+  updatedAt: datetime("updated_at", { fsp: 3 }).notNull()
+});
+var pwPlans = mysqlTable(
+  PW_TABLES.plans,
+  {
+    id: varchar("id", { length: 255 }).primaryKey(),
+    planId: varchar("plan_id", { length: 255 }).notNull(),
+    version: int("version").notNull(),
+    group: varchar("group", { length: 255 }).notNull(),
+    isDefault: boolean("is_default").notNull(),
+    name: varchar("name", { length: 255 }),
+    priceMinor: bigint("price_minor", { mode: "number" }),
+    priceCurrency: varchar("price_currency", { length: 255 }),
+    priceInterval: varchar("price_interval", { length: 255 }).$type(),
+    features: json("features").$type().notNull(),
+    providerRefs: json("provider_refs").$type().notNull(),
+    pushedAt: datetime("pushed_at", { fsp: 3 }).notNull()
+  },
+  (t) => [uniqueIndex("pw_plans_plan_id_version_uq").on(t.planId, t.version)]
+);
+var pwSubscriptions = mysqlTable(
+  PW_TABLES.subscriptions,
+  {
+    id: varchar("id", { length: 255 }).primaryKey(),
+    customerId: varchar("customer_id", { length: 255 }).notNull().references(() => pwCustomers.id),
+    planId: varchar("plan_id", { length: 255 }).notNull(),
+    planVersion: int("plan_version").notNull(),
+    group: varchar("group", { length: 255, ...utf8mb4Bin }).notNull(),
+    status: varchar("status", { length: 255, ...utf8mb4Bin }).$type().notNull(),
+    provider: varchar("provider", { length: 255 }),
+    providerSubscriptionRef: varchar("provider_subscription_ref", { length: 255 }),
+    currentPeriodStart: datetime("current_period_start", { fsp: 3 }).notNull(),
+    currentPeriodEnd: datetime("current_period_end", { fsp: 3 }).notNull(),
+    cancelAtPeriodEnd: boolean("cancel_at_period_end").notNull(),
+    createdAt: datetime("created_at", { fsp: 3 }).notNull(),
+    updatedAt: datetime("updated_at", { fsp: 3 }).notNull(),
+    // STORED generated column emulating the partial-unique rule (see module
+    // header) — never write to this column directly.
+    activeSlot: char("active_slot", { length: 1 }).generatedAlwaysAs(
+      sql`case when ${sql.identifier("status")} in (${ACTIVE_STATUS_SQL_LIST}) then 'x' else null end`,
+      { mode: "stored" }
+    )
+  },
+  (t) => [uniqueIndex("pw_subscriptions_active_uq").on(t.customerId, t.group, t.activeSlot)]
+);
+var pwFeatureBalances = mysqlTable(
+  PW_TABLES.featureBalances,
+  {
+    id: varchar("id", { length: 255 }).primaryKey(),
+    customerId: varchar("customer_id", { length: 255 }).notNull().references(() => pwCustomers.id),
+    featureId: varchar("feature_id", { length: 255 }).notNull(),
+    group: varchar("group", { length: 255, ...utf8mb4Bin }).notNull(),
+    used: bigint("used", { mode: "number" }).notNull(),
+    limit: bigint("limit", { mode: "number" }).notNull(),
+    resetInterval: varchar("reset_interval", { length: 255 }).$type().notNull(),
+    anchor: datetime("anchor", { fsp: 3 }).notNull(),
+    periodStart: datetime("period_start", { fsp: 3 }).notNull(),
+    periodEnd: datetime("period_end", { fsp: 3 }).notNull(),
+    planId: varchar("plan_id", { length: 255 }).notNull(),
+    planVersion: int("plan_version").notNull(),
+    updatedAt: datetime("updated_at", { fsp: 3 }).notNull()
+  },
+  (t) => [
+    uniqueIndex("pw_feature_balances_customer_feature_group_uq").on(
+      t.customerId,
+      t.featureId,
+      t.group
+    )
+  ]
+);
+var pwWebhookEvents = mysqlTable(PW_TABLES.webhookEvents, {
+  dedupeKey: varchar("dedupe_key", { length: 255 }).primaryKey(),
+  provider: varchar("provider", { length: 255 }).notNull(),
+  type: varchar("type", { length: 255 }).notNull(),
+  receivedAt: datetime("received_at", { fsp: 3 }).notNull(),
+  claimedAt: datetime("claimed_at", { fsp: 3 }),
+  appliedAt: datetime("applied_at", { fsp: 3 })
+});
+var mysqlSchema = {
+  pwCustomers,
+  pwPlans,
+  pwSubscriptions,
+  pwFeatureBalances,
+  pwWebhookEvents
+};
+var REQUIRED_TABLES = [
+  PW_TABLES.customers,
+  PW_TABLES.plans,
+  PW_TABLES.subscriptions,
+  PW_TABLES.featureBalances,
+  PW_TABLES.webhookEvents
+];
+var SCHEMA_FILE_HINT = '"payweave/db/drizzle"\'s published schema (src/db/drizzle/schema/{pg,mysql,sqlite}.ts \u2014 docs/v1/database.md \xA74) \u2014 merge it into your own Drizzle schema and run `drizzle-kit push` or `drizzle-kit generate`/`migrate`.';
+function missingTablesError(missing) {
+  return new PayweaveConfigError(
+    `payweave/db/drizzle: the following Payweave tables do not exist yet in the connected database: ${missing.join(", ")}. Merge ${SCHEMA_FILE_HINT}`
+  );
+}
+async function findMissingTables(probe) {
+  const missing = [];
+  for (const table of REQUIRED_TABLES) {
+    if (!await probe(table)) missing.push(table);
+  }
+  return missing;
+}
+function createVerifier(probe) {
+  let cached;
+  return function ensureVerified() {
+    cached ??= (async () => {
+      const missing = await findMissingTables(probe);
+      if (missing.length > 0) throw missingTablesError(missing);
+    })().catch((error) => {
+      cached = void 0;
+      throw error;
+    });
+    return cached;
+  };
+}
+async function findMissingTablesForStatus(probe) {
+  return findMissingTables(probe);
+}
+function makeSqliteTableProbe(db) {
+  return async (table) => {
+    try {
+      await db.run(sql`select 1 from ${sql.identifier(table)} limit 0`);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+function makeSqlTableProbe(db) {
+  return async (table) => {
+    try {
+      await db.execute(sql`select 1 from ${sql.identifier(table)} limit 0`);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+
+// src/db/drizzle/mysql-adapter.ts
+var DRIZZLE_KIT_INSTRUCTIONS = 'payweave/db/drizzle never runs migrations for you. Merge "payweave/db/drizzle"\'s published schema (see `./schema/mysql.ts`) into your own Drizzle schema, then run `drizzle-kit push` (dev) or `drizzle-kit generate` + `drizzle-kit migrate` (tracked migrations) yourself.';
+function asWriteResult(raw) {
+  const header = Array.isArray(raw) ? raw[0] : raw;
+  const affectedRows = header?.affectedRows;
+  return { affectedRows: typeof affectedRows === "number" ? affectedRows : 0 };
+}
+function buildMysqlAdapter(db) {
+  const ensureVerified = createVerifier(makeSqlTableProbe(db));
+  function guarded(fn) {
+    return async (...args) => {
+      await ensureVerified();
+      return fn(...args);
+    };
+  }
+  return {
+    dialect: "mysql",
+    customers: {
+      getByExternalId: guarded((externalId) => customersGetByExternalId(db, externalId)),
+      upsert: guarded((input) => customersUpsert(db, input)),
+      linkProviderRef: guarded(
+        (externalId, provider, ref) => customersLinkProviderRef(db, externalId, provider, ref)
+      )
+    },
+    plans: {
+      getActiveVersion: guarded((planId) => plansGetActiveVersion(db, planId)),
+      listActive: guarded(() => plansListActive(db)),
+      pushVersion: guarded((plan) => plansPushVersion(db, plan))
+    },
+    subscriptions: {
+      getActive: guarded(
+        (customerId, group) => subscriptionsGetActive(db, customerId, group)
+      ),
+      create: guarded((input) => subscriptionsCreate(db, input)),
+      update: guarded(
+        (id, patch) => subscriptionsUpdate(db, id, patch)
+      )
+    },
+    balances: {
+      get: guarded(
+        (customerId, featureId, group) => balancesGet(db, customerId, featureId, group)
+      ),
+      consume: guarded((input) => balancesConsume(db, input)),
+      resetTo: guarded(
+        (customerId, featureId, group, init) => balancesResetTo(db, customerId, featureId, group, init)
+      )
+    },
+    webhookEvents: {
+      claim: guarded(
+        (dedupeKey, meta) => webhookEventsClaim(db, dedupeKey, meta)
+      ),
+      markApplied: guarded((dedupeKey) => webhookEventsMarkApplied(db, dedupeKey))
+    },
+    migrations: {
+      status: async () => {
+        const missing = await findMissingTablesForStatus(makeSqlTableProbe(db));
+        return missing.length > 0 ? { pending: ["0001_init"], applied: [] } : { pending: [], applied: ["0001_init"] };
+      },
+      apply: () => Promise.resolve({ applied: [], instructions: DRIZZLE_KIT_INSTRUCTIONS })
+    },
+    transaction: (fn) => db.transaction((tx) => fn(buildMysqlAdapter(tx)))
+  };
+}
+async function customersGetByExternalId(db, externalId) {
+  const rows = await db.select().from(pwCustomers).where(eq(pwCustomers.externalId, externalId));
+  return rows[0] ?? null;
+}
+async function customersUpsert(db, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  const set = { updatedAt: now };
+  if (input.email !== void 0) set.email = input.email;
+  try {
+    await db.insert(pwCustomers).values({
+      id,
+      externalId: input.externalId,
+      providerIds: {},
+      email: input.email ?? null,
+      createdAt: now,
+      updatedAt: now
+    }).onDuplicateKeyUpdate({ set });
+    const rows = await db.select().from(pwCustomers).where(eq(pwCustomers.externalId, input.externalId));
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (mysql): customers.upsert returned no row");
+    return row;
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (mysql): customers.upsert(${JSON.stringify(input.externalId)}) failed.`
+    );
+  }
+}
+async function customersLinkProviderRef(db, externalId, provider, ref) {
+  await db.transaction(async (tx) => {
+    const rows = await tx.select().from(pwCustomers).where(eq(pwCustomers.externalId, externalId)).for("update");
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/drizzle (mysql): customers.linkProviderRef: no customer with externalId ${JSON.stringify(externalId)}.`
+      );
+    }
+    const providerIds = { ...row.providerIds, [provider]: ref };
+    await tx.update(pwCustomers).set({ providerIds, updatedAt: /* @__PURE__ */ new Date() }).where(eq(pwCustomers.externalId, externalId));
+  });
+}
+async function plansGetActiveVersion(db, planId) {
+  const rows = await db.select().from(pwPlans).where(eq(pwPlans.planId, planId)).orderBy(sql`${pwPlans.version} desc`).limit(1);
+  return rows[0] ?? null;
+}
+async function plansListActive(db) {
+  const latest = db.select({
+    planId: pwPlans.planId,
+    version: sql`max(${pwPlans.version})`.as("max_version")
+  }).from(pwPlans).groupBy(pwPlans.planId).as("latest");
+  return db.select({
+    id: pwPlans.id,
+    planId: pwPlans.planId,
+    version: pwPlans.version,
+    group: pwPlans.group,
+    isDefault: pwPlans.isDefault,
+    name: pwPlans.name,
+    priceMinor: pwPlans.priceMinor,
+    priceCurrency: pwPlans.priceCurrency,
+    priceInterval: pwPlans.priceInterval,
+    features: pwPlans.features,
+    providerRefs: pwPlans.providerRefs,
+    pushedAt: pwPlans.pushedAt
+  }).from(pwPlans).innerJoin(latest, and(eq(latest.planId, pwPlans.planId), eq(latest.version, pwPlans.version)));
+}
+async function plansPushVersion(db, plan) {
+  return db.transaction(async (tx) => {
+    const activeRows = await tx.select().from(pwPlans).where(eq(pwPlans.planId, plan.planId)).orderBy(sql`${pwPlans.version} desc`).limit(1).for("update");
+    const active = activeRows[0] ?? null;
+    if (active && planContentEquals(active, plan)) {
+      return active;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const id = generatePwId(now.getTime());
+    const nextVersion = (active?.version ?? 0) + 1;
+    await tx.insert(pwPlans).values({
+      id,
+      planId: plan.planId,
+      version: nextVersion,
+      group: plan.group,
+      isDefault: plan.isDefault,
+      name: plan.name,
+      priceMinor: plan.priceMinor,
+      priceCurrency: plan.priceCurrency,
+      priceInterval: plan.priceInterval,
+      features: plan.features,
+      providerRefs: plan.providerRefs,
+      pushedAt: now
+    });
+    const rows = await tx.select().from(pwPlans).where(eq(pwPlans.id, id));
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (mysql): plans.pushVersion returned no row");
+    return row;
+  });
+}
+async function subscriptionsGetActive(db, customerId, group) {
+  const rows = await db.select().from(pwSubscriptions).where(
+    and(
+      eq(pwSubscriptions.customerId, customerId),
+      eq(pwSubscriptions.group, group),
+      sql`${pwSubscriptions.status} in ${PW_ACTIVE_SUBSCRIPTION_STATUSES}`
+    )
+  );
+  return rows[0] ?? null;
+}
+async function subscriptionsCreate(db, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    await db.insert(pwSubscriptions).values({
+      id,
+      customerId: input.customerId,
+      planId: input.planId,
+      planVersion: input.planVersion,
+      group: input.group,
+      status: input.status,
+      provider: input.provider,
+      providerSubscriptionRef: input.providerSubscriptionRef,
+      currentPeriodStart: input.currentPeriodStart,
+      currentPeriodEnd: input.currentPeriodEnd,
+      cancelAtPeriodEnd: input.cancelAtPeriodEnd,
+      createdAt: now,
+      updatedAt: now
+    });
+    const rows = await db.select().from(pwSubscriptions).where(eq(pwSubscriptions.id, id));
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (mysql): subscriptions.create returned no row");
+    return row;
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (mysql): 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(db, id, patch) {
+  const set = { updatedAt: /* @__PURE__ */ new Date() };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== void 0) set[key] = value;
+  }
+  try {
+    await db.update(pwSubscriptions).set(set).where(eq(pwSubscriptions.id, id));
+    const rows = await db.select().from(pwSubscriptions).where(eq(pwSubscriptions.id, id));
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/drizzle (mysql): subscriptions.update: no subscription with id ${JSON.stringify(id)}.`
+      );
+    }
+    return row;
+  } catch (error) {
+    if (error instanceof PayweaveNotFoundError) throw error;
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (mysql): subscriptions.update(${JSON.stringify(id)}) failed.`
+    );
+  }
+}
+async function balancesGet(db, customerId, featureId, group) {
+  const rows = await db.select().from(pwFeatureBalances).where(
+    and(
+      eq(pwFeatureBalances.customerId, customerId),
+      eq(pwFeatureBalances.featureId, featureId),
+      eq(pwFeatureBalances.group, group)
+    )
+  );
+  return rows[0] ?? null;
+}
+async function balancesConsume(db, input) {
+  return db.transaction(async (tx) => {
+    const existingRows = await tx.select().from(pwFeatureBalances).where(
+      and(
+        eq(pwFeatureBalances.customerId, input.customerId),
+        eq(pwFeatureBalances.featureId, input.featureId),
+        eq(pwFeatureBalances.group, input.group)
+      )
+    ).for("update");
+    const existingRow = existingRows[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);
+      await tx.insert(pwFeatureBalances).values({
+        id,
+        customerId: input.customerId,
+        featureId: input.featureId,
+        group: input.group,
+        used,
+        limit: input.init.limit,
+        resetInterval: input.init.resetInterval,
+        anchor: input.init.anchor,
+        periodStart: new Date(period2.start),
+        periodEnd: new Date(period2.end),
+        planId: input.init.planId,
+        planVersion: input.init.planVersion,
+        updatedAt: input.now
+      });
+      const rows2 = await tx.select().from(pwFeatureBalances).where(eq(pwFeatureBalances.id, id));
+      const row = rows2[0];
+      if (!row) {
+        throw new Error("drizzle adapter (mysql): balances.consume (create) returned no row");
+      }
+      return { ...row, applied: applied2 };
+    }
+    const resetDue = nowMs >= existingRow.periodEnd.getTime();
+    const baseUsed = resetDue ? 0 : existingRow.used;
+    const period = resetDue ? currentPeriod(existingRow.anchor.getTime(), existingRow.resetInterval, nowMs) : { start: existingRow.periodStart.getTime(), end: existingRow.periodEnd.getTime() };
+    const remaining = existingRow.limit - baseUsed;
+    const applied = input.conditional !== true || remaining >= input.amount;
+    if (!applied && !resetDue) {
+      return { ...existingRow, applied: false };
+    }
+    const finalUsed = applied ? baseUsed + input.amount : baseUsed;
+    await tx.update(pwFeatureBalances).set({
+      used: finalUsed,
+      periodStart: new Date(period.start),
+      periodEnd: new Date(period.end),
+      updatedAt: input.now
+    }).where(eq(pwFeatureBalances.id, existingRow.id));
+    const rows = await tx.select().from(pwFeatureBalances).where(eq(pwFeatureBalances.id, existingRow.id));
+    const updatedRow = rows[0];
+    if (!updatedRow) {
+      throw new Error("drizzle adapter (mysql): balances.consume (update) returned no row");
+    }
+    return { ...updatedRow, applied };
+  });
+}
+async function balancesResetTo(db, 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 db.insert(pwFeatureBalances).values({
+    id,
+    customerId,
+    featureId,
+    group,
+    used: 0,
+    limit: init.limit,
+    resetInterval: init.resetInterval,
+    anchor: init.anchor,
+    periodStart: new Date(period.start),
+    periodEnd: new Date(period.end),
+    planId: init.planId,
+    planVersion: init.planVersion,
+    updatedAt: now
+  }).onDuplicateKeyUpdate({
+    set: {
+      used: 0,
+      limit: init.limit,
+      resetInterval: init.resetInterval,
+      anchor: init.anchor,
+      periodStart: new Date(period.start),
+      periodEnd: new Date(period.end),
+      planId: init.planId,
+      planVersion: init.planVersion,
+      updatedAt: now
+    }
+  });
+}
+async function webhookEventsClaim(db, dedupeKey, meta) {
+  const staleClaimAfterMs = meta.staleClaimAfterMs ?? DEFAULT_STALE_CLAIM_AFTER_MS;
+  const staleThreshold = new Date(meta.now.getTime() - staleClaimAfterMs);
+  const raw = await db.execute(
+    sql`insert into ${pwWebhookEvents} (dedupe_key, provider, type, received_at, claimed_at, applied_at)
+        values (${dedupeKey}, ${meta.provider}, ${meta.type}, ${meta.now}, ${meta.now}, null)
+        on duplicate key update claimed_at = if(applied_at is null and claimed_at <= ${staleThreshold}, ${meta.now}, claimed_at)`
+  );
+  const result = asWriteResult(raw);
+  return result.affectedRows === 1 || result.affectedRows === 2;
+}
+async function webhookEventsMarkApplied(db, dedupeKey) {
+  await db.update(pwWebhookEvents).set({ appliedAt: /* @__PURE__ */ new Date() }).where(eq(pwWebhookEvents.dedupeKey, dedupeKey));
+}
+var ACTIVE_STATUS_SQL_LIST2 = sql.raw(
+  PW_ACTIVE_SUBSCRIPTION_STATUSES.map((s) => `'${s}'`).join(", ")
+);
+var pwCustomers2 = pgTable(PW_TABLES.customers, {
+  id: text("id").primaryKey(),
+  externalId: text("external_id").notNull().unique(),
+  providerIds: jsonb("provider_ids").$type().notNull(),
+  email: text("email"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+});
+var pwPlans2 = pgTable(
+  PW_TABLES.plans,
+  {
+    id: text("id").primaryKey(),
+    planId: text("plan_id").notNull(),
+    version: integer("version").notNull(),
+    group: text("group").notNull(),
+    isDefault: boolean$1("is_default").notNull(),
+    name: text("name"),
+    priceMinor: bigint$1("price_minor", { mode: "number" }),
+    priceCurrency: text("price_currency"),
+    priceInterval: text("price_interval").$type(),
+    features: jsonb("features").$type().notNull(),
+    providerRefs: jsonb("provider_refs").$type().notNull(),
+    pushedAt: timestamp("pushed_at", { withTimezone: true }).notNull()
+  },
+  (t) => [uniqueIndex$1("pw_plans_plan_id_version_uq").on(t.planId, t.version)]
+);
+var pwSubscriptions2 = pgTable(
+  PW_TABLES.subscriptions,
+  {
+    id: text("id").primaryKey(),
+    customerId: text("customer_id").notNull().references(() => pwCustomers2.id),
+    planId: text("plan_id").notNull(),
+    planVersion: integer("plan_version").notNull(),
+    group: text("group").notNull(),
+    status: text("status").$type().notNull(),
+    provider: text("provider"),
+    providerSubscriptionRef: text("provider_subscription_ref"),
+    currentPeriodStart: timestamp("current_period_start", { withTimezone: true }).notNull(),
+    currentPeriodEnd: timestamp("current_period_end", { withTimezone: true }).notNull(),
+    cancelAtPeriodEnd: boolean$1("cancel_at_period_end").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+  },
+  (t) => [
+    uniqueIndex$1("pw_subscriptions_active_uq").on(t.customerId, t.group).where(sql`${t.status} IN (${ACTIVE_STATUS_SQL_LIST2})`)
+  ]
+);
+var pwFeatureBalances2 = pgTable(
+  PW_TABLES.featureBalances,
+  {
+    id: text("id").primaryKey(),
+    customerId: text("customer_id").notNull().references(() => pwCustomers2.id),
+    featureId: text("feature_id").notNull(),
+    group: text("group").notNull(),
+    used: bigint$1("used", { mode: "number" }).notNull(),
+    limit: bigint$1("limit", { mode: "number" }).notNull(),
+    resetInterval: text("reset_interval").$type().notNull(),
+    anchor: timestamp("anchor", { withTimezone: true }).notNull(),
+    periodStart: timestamp("period_start", { withTimezone: true }).notNull(),
+    periodEnd: timestamp("period_end", { withTimezone: true }).notNull(),
+    planId: text("plan_id").notNull(),
+    planVersion: integer("plan_version").notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+  },
+  (t) => [
+    uniqueIndex$1("pw_feature_balances_customer_feature_group_uq").on(
+      t.customerId,
+      t.featureId,
+      t.group
+    )
+  ]
+);
+var pwWebhookEvents2 = pgTable(PW_TABLES.webhookEvents, {
+  dedupeKey: text("dedupe_key").primaryKey(),
+  provider: text("provider").notNull(),
+  type: text("type").notNull(),
+  receivedAt: timestamp("received_at", { withTimezone: true }).notNull(),
+  claimedAt: timestamp("claimed_at", { withTimezone: true }),
+  appliedAt: timestamp("applied_at", { withTimezone: true })
+});
+var pgSchema = {
+  pwCustomers: pwCustomers2,
+  pwPlans: pwPlans2,
+  pwSubscriptions: pwSubscriptions2,
+  pwFeatureBalances: pwFeatureBalances2,
+  pwWebhookEvents: pwWebhookEvents2
+};
+
+// src/db/drizzle/postgres-adapter.ts
+var DRIZZLE_KIT_INSTRUCTIONS2 = 'payweave/db/drizzle never runs migrations for you. Merge "payweave/db/drizzle"\'s published schema (see `./schema/pg.ts`) into your own Drizzle schema, then run `drizzle-kit push` (dev) or `drizzle-kit generate` + `drizzle-kit migrate` (tracked migrations) yourself.';
+function buildPostgresAdapter(db) {
+  const ensureVerified = createVerifier(makeSqlTableProbe(db));
+  function guarded(fn) {
+    return async (...args) => {
+      await ensureVerified();
+      return fn(...args);
+    };
+  }
+  return {
+    dialect: "postgres",
+    customers: {
+      getByExternalId: guarded((externalId) => customersGetByExternalId2(db, externalId)),
+      upsert: guarded((input) => customersUpsert2(db, input)),
+      linkProviderRef: guarded(
+        (externalId, provider, ref) => customersLinkProviderRef2(db, externalId, provider, ref)
+      )
+    },
+    plans: {
+      getActiveVersion: guarded((planId) => plansGetActiveVersion2(db, planId)),
+      listActive: guarded(() => plansListActive2(db)),
+      pushVersion: guarded((plan) => plansPushVersion2(db, plan))
+    },
+    subscriptions: {
+      getActive: guarded(
+        (customerId, group) => subscriptionsGetActive2(db, customerId, group)
+      ),
+      create: guarded((input) => subscriptionsCreate2(db, input)),
+      update: guarded(
+        (id, patch) => subscriptionsUpdate2(db, id, patch)
+      )
+    },
+    balances: {
+      get: guarded(
+        (customerId, featureId, group) => balancesGet2(db, customerId, featureId, group)
+      ),
+      consume: guarded((input) => balancesConsume2(db, input)),
+      resetTo: guarded(
+        (customerId, featureId, group, init) => balancesResetTo2(db, customerId, featureId, group, init)
+      )
+    },
+    webhookEvents: {
+      claim: guarded(
+        (dedupeKey, meta) => webhookEventsClaim2(db, dedupeKey, meta)
+      ),
+      markApplied: guarded((dedupeKey) => webhookEventsMarkApplied2(db, dedupeKey))
+    },
+    migrations: {
+      status: async () => {
+        const missing = await findMissingTablesForStatus(makeSqlTableProbe(db));
+        return missing.length > 0 ? { pending: ["0001_init"], applied: [] } : { pending: [], applied: ["0001_init"] };
+      },
+      apply: () => Promise.resolve({ applied: [], instructions: DRIZZLE_KIT_INSTRUCTIONS2 })
+    },
+    transaction: (fn) => db.transaction((tx) => fn(buildPostgresAdapter(tx)))
+  };
+}
+async function customersGetByExternalId2(db, externalId) {
+  const rows = await db.select().from(pwCustomers2).where(eq(pwCustomers2.externalId, externalId));
+  return rows[0] ?? null;
+}
+async function customersUpsert2(db, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const rows = await db.insert(pwCustomers2).values({
+      id,
+      externalId: input.externalId,
+      providerIds: {},
+      email: input.email ?? null,
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: pwCustomers2.externalId,
+      set: {
+        email: sql`coalesce(excluded.email, ${pwCustomers2.email})`,
+        updatedAt: now
+      }
+    }).returning();
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (postgres): customers.upsert returned no row");
+    return row;
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (postgres): customers.upsert(${JSON.stringify(input.externalId)}) failed.`
+    );
+  }
+}
+async function customersLinkProviderRef2(db, externalId, provider, ref) {
+  await db.transaction(async (tx) => {
+    const rows = await tx.select().from(pwCustomers2).where(eq(pwCustomers2.externalId, externalId)).for("update");
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/drizzle (postgres): customers.linkProviderRef: no customer with externalId ${JSON.stringify(externalId)}.`
+      );
+    }
+    const providerIds = { ...row.providerIds, [provider]: ref };
+    await tx.update(pwCustomers2).set({ providerIds, updatedAt: /* @__PURE__ */ new Date() }).where(eq(pwCustomers2.externalId, externalId));
+  });
+}
+async function plansGetActiveVersion2(db, planId) {
+  const rows = await db.select().from(pwPlans2).where(eq(pwPlans2.planId, planId)).orderBy(sql`${pwPlans2.version} desc`).limit(1);
+  return rows[0] ?? null;
+}
+async function plansListActive2(db) {
+  const latest = db.select({
+    planId: pwPlans2.planId,
+    version: sql`max(${pwPlans2.version})`.as("max_version")
+  }).from(pwPlans2).groupBy(pwPlans2.planId).as("latest");
+  return db.select({
+    id: pwPlans2.id,
+    planId: pwPlans2.planId,
+    version: pwPlans2.version,
+    group: pwPlans2.group,
+    isDefault: pwPlans2.isDefault,
+    name: pwPlans2.name,
+    priceMinor: pwPlans2.priceMinor,
+    priceCurrency: pwPlans2.priceCurrency,
+    priceInterval: pwPlans2.priceInterval,
+    features: pwPlans2.features,
+    providerRefs: pwPlans2.providerRefs,
+    pushedAt: pwPlans2.pushedAt
+  }).from(pwPlans2).innerJoin(latest, and(eq(latest.planId, pwPlans2.planId), eq(latest.version, pwPlans2.version)));
+}
+async function plansPushVersion2(db, plan) {
+  return db.transaction(async (tx) => {
+    const activeRows = await tx.select().from(pwPlans2).where(eq(pwPlans2.planId, plan.planId)).orderBy(sql`${pwPlans2.version} desc`).limit(1).for("update");
+    const active = activeRows[0] ?? 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 = await tx.insert(pwPlans2).values({
+      id,
+      planId: plan.planId,
+      version: nextVersion,
+      group: plan.group,
+      isDefault: plan.isDefault,
+      name: plan.name,
+      priceMinor: plan.priceMinor,
+      priceCurrency: plan.priceCurrency,
+      priceInterval: plan.priceInterval,
+      features: plan.features,
+      providerRefs: plan.providerRefs,
+      pushedAt: now
+    }).returning();
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (postgres): plans.pushVersion returned no row");
+    return row;
+  });
+}
+async function subscriptionsGetActive2(db, customerId, group) {
+  const rows = await db.select().from(pwSubscriptions2).where(
+    and(
+      eq(pwSubscriptions2.customerId, customerId),
+      eq(pwSubscriptions2.group, group),
+      sql`${pwSubscriptions2.status} in ${PW_ACTIVE_SUBSCRIPTION_STATUSES}`
+    )
+  );
+  return rows[0] ?? null;
+}
+async function subscriptionsCreate2(db, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const rows = await db.insert(pwSubscriptions2).values({
+      id,
+      customerId: input.customerId,
+      planId: input.planId,
+      planVersion: input.planVersion,
+      group: input.group,
+      status: input.status,
+      provider: input.provider,
+      providerSubscriptionRef: input.providerSubscriptionRef,
+      currentPeriodStart: input.currentPeriodStart,
+      currentPeriodEnd: input.currentPeriodEnd,
+      cancelAtPeriodEnd: input.cancelAtPeriodEnd,
+      createdAt: now,
+      updatedAt: now
+    }).returning();
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (postgres): subscriptions.create returned no row");
+    return row;
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (postgres): 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 subscriptionsUpdate2(db, id, patch) {
+  const set = { updatedAt: /* @__PURE__ */ new Date() };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== void 0) set[key] = value;
+  }
+  try {
+    const rows = await db.update(pwSubscriptions2).set(set).where(eq(pwSubscriptions2.id, id)).returning();
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/drizzle (postgres): subscriptions.update: no subscription with id ${JSON.stringify(id)}.`
+      );
+    }
+    return row;
+  } catch (error) {
+    if (error instanceof PayweaveNotFoundError) throw error;
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (postgres): subscriptions.update(${JSON.stringify(id)}) failed.`
+    );
+  }
+}
+async function balancesGet2(db, customerId, featureId, group) {
+  const rows = await db.select().from(pwFeatureBalances2).where(
+    and(
+      eq(pwFeatureBalances2.customerId, customerId),
+      eq(pwFeatureBalances2.featureId, featureId),
+      eq(pwFeatureBalances2.group, group)
+    )
+  );
+  return rows[0] ?? null;
+}
+async function balancesConsume2(db, input) {
+  return db.transaction(async (tx) => {
+    const existingRows = await tx.select().from(pwFeatureBalances2).where(
+      and(
+        eq(pwFeatureBalances2.customerId, input.customerId),
+        eq(pwFeatureBalances2.featureId, input.featureId),
+        eq(pwFeatureBalances2.group, input.group)
+      )
+    ).for("update");
+    const existingRow = existingRows[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 rows2 = await tx.insert(pwFeatureBalances2).values({
+        id,
+        customerId: input.customerId,
+        featureId: input.featureId,
+        group: input.group,
+        used,
+        limit: input.init.limit,
+        resetInterval: input.init.resetInterval,
+        anchor: input.init.anchor,
+        periodStart: new Date(period2.start),
+        periodEnd: new Date(period2.end),
+        planId: input.init.planId,
+        planVersion: input.init.planVersion,
+        updatedAt: input.now
+      }).returning();
+      const row = rows2[0];
+      if (!row) {
+        throw new Error("drizzle adapter (postgres): balances.consume (create) returned no row");
+      }
+      return { ...row, applied: applied2 };
+    }
+    const resetDue = nowMs >= existingRow.periodEnd.getTime();
+    const baseUsed = resetDue ? 0 : existingRow.used;
+    const period = resetDue ? currentPeriod(existingRow.anchor.getTime(), existingRow.resetInterval, nowMs) : { start: existingRow.periodStart.getTime(), end: existingRow.periodEnd.getTime() };
+    const remaining = existingRow.limit - baseUsed;
+    const applied = input.conditional !== true || remaining >= input.amount;
+    if (!applied && !resetDue) {
+      return { ...existingRow, applied: false };
+    }
+    const finalUsed = applied ? baseUsed + input.amount : baseUsed;
+    const rows = await tx.update(pwFeatureBalances2).set({
+      used: finalUsed,
+      periodStart: new Date(period.start),
+      periodEnd: new Date(period.end),
+      updatedAt: input.now
+    }).where(eq(pwFeatureBalances2.id, existingRow.id)).returning();
+    const updatedRow = rows[0];
+    if (!updatedRow) {
+      throw new Error("drizzle adapter (postgres): balances.consume (update) returned no row");
+    }
+    return { ...updatedRow, applied };
+  });
+}
+async function balancesResetTo2(db, 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 db.insert(pwFeatureBalances2).values({
+    id,
+    customerId,
+    featureId,
+    group,
+    used: 0,
+    limit: init.limit,
+    resetInterval: init.resetInterval,
+    anchor: init.anchor,
+    periodStart: new Date(period.start),
+    periodEnd: new Date(period.end),
+    planId: init.planId,
+    planVersion: init.planVersion,
+    updatedAt: now
+  }).onConflictDoUpdate({
+    target: [pwFeatureBalances2.customerId, pwFeatureBalances2.featureId, pwFeatureBalances2.group],
+    set: {
+      used: 0,
+      limit: init.limit,
+      resetInterval: init.resetInterval,
+      anchor: init.anchor,
+      periodStart: new Date(period.start),
+      periodEnd: new Date(period.end),
+      planId: init.planId,
+      planVersion: init.planVersion,
+      updatedAt: now
+    }
+  });
+}
+async function webhookEventsClaim2(db, dedupeKey, meta) {
+  const staleClaimAfterMs = meta.staleClaimAfterMs ?? DEFAULT_STALE_CLAIM_AFTER_MS;
+  const staleThreshold = new Date(meta.now.getTime() - staleClaimAfterMs);
+  const rows = await db.insert(pwWebhookEvents2).values({
+    dedupeKey,
+    provider: meta.provider,
+    type: meta.type,
+    receivedAt: meta.now,
+    claimedAt: meta.now,
+    appliedAt: null
+  }).onConflictDoUpdate({
+    target: pwWebhookEvents2.dedupeKey,
+    set: { claimedAt: meta.now },
+    // See the sqlite dialect file's identical comment: `and(...)` with two
+    // fixed conditions never actually returns `undefined`.
+    setWhere: and(
+      sql`${pwWebhookEvents2.appliedAt} is null`,
+      sql`${pwWebhookEvents2.claimedAt} <= ${staleThreshold}`
+    )
+  }).returning({ claimedAt: pwWebhookEvents2.claimedAt });
+  const row = rows[0];
+  return row !== void 0 && row.claimedAt !== null && row.claimedAt.getTime() === meta.now.getTime();
+}
+async function webhookEventsMarkApplied2(db, dedupeKey) {
+  await db.update(pwWebhookEvents2).set({ appliedAt: /* @__PURE__ */ new Date() }).where(eq(pwWebhookEvents2.dedupeKey, dedupeKey));
+}
+var ACTIVE_STATUS_SQL_LIST3 = sql.raw(
+  PW_ACTIVE_SUBSCRIPTION_STATUSES.map((s) => `'${s}'`).join(", ")
+);
+var pwCustomers3 = sqliteTable(PW_TABLES.customers, {
+  id: text$1("id").primaryKey(),
+  externalId: text$1("external_id").notNull().unique(),
+  providerIds: text$1("provider_ids", { mode: "json" }).$type().notNull(),
+  email: text$1("email"),
+  createdAt: integer$1("created_at", { mode: "timestamp_ms" }).notNull(),
+  updatedAt: integer$1("updated_at", { mode: "timestamp_ms" }).notNull()
+});
+var pwPlans3 = sqliteTable(
+  PW_TABLES.plans,
+  {
+    id: text$1("id").primaryKey(),
+    planId: text$1("plan_id").notNull(),
+    version: integer$1("version").notNull(),
+    group: text$1("group").notNull(),
+    isDefault: integer$1("is_default", { mode: "boolean" }).notNull(),
+    name: text$1("name"),
+    priceMinor: integer$1("price_minor"),
+    priceCurrency: text$1("price_currency"),
+    priceInterval: text$1("price_interval").$type(),
+    features: text$1("features", { mode: "json" }).$type().notNull(),
+    providerRefs: text$1("provider_refs", { mode: "json" }).$type().notNull(),
+    pushedAt: integer$1("pushed_at", { mode: "timestamp_ms" }).notNull()
+  },
+  (t) => [uniqueIndex$2("pw_plans_plan_id_version_uq").on(t.planId, t.version)]
+);
+var pwSubscriptions3 = sqliteTable(
+  PW_TABLES.subscriptions,
+  {
+    id: text$1("id").primaryKey(),
+    customerId: text$1("customer_id").notNull(),
+    planId: text$1("plan_id").notNull(),
+    planVersion: integer$1("plan_version").notNull(),
+    group: text$1("group").notNull(),
+    status: text$1("status").$type().notNull(),
+    provider: text$1("provider"),
+    providerSubscriptionRef: text$1("provider_subscription_ref"),
+    currentPeriodStart: integer$1("current_period_start", { mode: "timestamp_ms" }).notNull(),
+    currentPeriodEnd: integer$1("current_period_end", { mode: "timestamp_ms" }).notNull(),
+    cancelAtPeriodEnd: integer$1("cancel_at_period_end", { mode: "boolean" }).notNull(),
+    createdAt: integer$1("created_at", { mode: "timestamp_ms" }).notNull(),
+    updatedAt: integer$1("updated_at", { mode: "timestamp_ms" }).notNull()
+  },
+  (t) => [
+    uniqueIndex$2("pw_subscriptions_active_uq").on(t.customerId, t.group).where(sql`${t.status} IN (${ACTIVE_STATUS_SQL_LIST3})`)
+  ]
+);
+var pwFeatureBalances3 = sqliteTable(
+  PW_TABLES.featureBalances,
+  {
+    id: text$1("id").primaryKey(),
+    customerId: text$1("customer_id").notNull(),
+    featureId: text$1("feature_id").notNull(),
+    group: text$1("group").notNull(),
+    used: integer$1("used").notNull(),
+    limit: integer$1("limit").notNull(),
+    resetInterval: text$1("reset_interval").$type().notNull(),
+    anchor: integer$1("anchor", { mode: "timestamp_ms" }).notNull(),
+    periodStart: integer$1("period_start", { mode: "timestamp_ms" }).notNull(),
+    periodEnd: integer$1("period_end", { mode: "timestamp_ms" }).notNull(),
+    planId: text$1("plan_id").notNull(),
+    planVersion: integer$1("plan_version").notNull(),
+    updatedAt: integer$1("updated_at", { mode: "timestamp_ms" }).notNull()
+  },
+  (t) => [
+    uniqueIndex$2("pw_feature_balances_customer_feature_group_uq").on(
+      t.customerId,
+      t.featureId,
+      t.group
+    )
+  ]
+);
+var pwWebhookEvents3 = sqliteTable(PW_TABLES.webhookEvents, {
+  dedupeKey: text$1("dedupe_key").primaryKey(),
+  provider: text$1("provider").notNull(),
+  type: text$1("type").notNull(),
+  receivedAt: integer$1("received_at", { mode: "timestamp_ms" }).notNull(),
+  claimedAt: integer$1("claimed_at", { mode: "timestamp_ms" }),
+  appliedAt: integer$1("applied_at", { mode: "timestamp_ms" })
+});
+var sqliteSchema = {
+  pwCustomers: pwCustomers3,
+  pwPlans: pwPlans3,
+  pwSubscriptions: pwSubscriptions3,
+  pwFeatureBalances: pwFeatureBalances3,
+  pwWebhookEvents: pwWebhookEvents3
+};
+
+// src/db/drizzle/sqlite-adapter.ts
+var SerialQueue = class {
+  #tail = Promise.resolve();
+  run(fn) {
+    const result = this.#tail.then(fn);
+    this.#tail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+};
+var TopLevelRunner = class {
+  #queue = new SerialQueue();
+  enqueue(fn) {
+    return this.#queue.run(fn);
+  }
+  transaction(db, fn) {
+    return this.#queue.run(async () => {
+      await db.run(sql`BEGIN IMMEDIATE`);
+      try {
+        const nested = buildSqliteAdapter(db, new NestedRunner());
+        const result = await fn(nested);
+        await db.run(sql`COMMIT`);
+        return result;
+      } catch (error) {
+        try {
+          await db.run(sql`ROLLBACK`);
+        } catch {
+        }
+        throw error;
+      }
+    });
+  }
+};
+var NestedRunner = class {
+  enqueue(fn) {
+    return fn();
+  }
+  transaction(db, fn) {
+    return fn(buildSqliteAdapter(db, this));
+  }
+};
+function buildSqliteAdapter(db, runner = new TopLevelRunner()) {
+  const ensureVerified = createVerifier(makeSqliteTableProbe(db));
+  function guarded(fn) {
+    return (...args) => runner.enqueue(async () => {
+      await ensureVerified();
+      return fn(...args);
+    });
+  }
+  return {
+    dialect: "sqlite",
+    customers: {
+      getByExternalId: guarded((externalId) => customersGetByExternalId3(db, externalId)),
+      upsert: guarded((input) => customersUpsert3(db, input)),
+      linkProviderRef: guarded(
+        (externalId, provider, ref) => customersLinkProviderRef3(db, externalId, provider, ref)
+      )
+    },
+    plans: {
+      getActiveVersion: guarded((planId) => plansGetActiveVersion3(db, planId)),
+      listActive: guarded(() => plansListActive3(db)),
+      pushVersion: guarded((plan) => plansPushVersion3(db, plan))
+    },
+    subscriptions: {
+      getActive: guarded(
+        (customerId, group) => subscriptionsGetActive3(db, customerId, group)
+      ),
+      create: guarded((input) => subscriptionsCreate3(db, input)),
+      update: guarded(
+        (id, patch) => subscriptionsUpdate3(db, id, patch)
+      )
+    },
+    balances: {
+      get: guarded(
+        (customerId, featureId, group) => balancesGet3(db, customerId, featureId, group)
+      ),
+      consume: guarded((input) => balancesConsume3(db, input)),
+      resetTo: guarded(
+        (customerId, featureId, group, init) => balancesResetTo3(db, customerId, featureId, group, init)
+      )
+    },
+    webhookEvents: {
+      claim: guarded(
+        (dedupeKey, meta) => webhookEventsClaim3(db, dedupeKey, meta)
+      ),
+      markApplied: guarded((dedupeKey) => webhookEventsMarkApplied3(db, dedupeKey))
+    },
+    migrations: {
+      status: () => sqliteMigrationsStatus(db),
+      apply: () => Promise.resolve(sqliteMigrationsApply())
+    },
+    transaction: (fn) => runner.transaction(db, fn)
+  };
+}
+var DRIZZLE_KIT_INSTRUCTIONS3 = 'payweave/db/drizzle never runs migrations for you. Merge "payweave/db/drizzle"\'s published schema (see `./schema/sqlite.ts`) into your own Drizzle schema, then run `drizzle-kit push` (dev) or `drizzle-kit generate` + `drizzle-kit migrate` (tracked migrations) yourself.';
+function sqliteMigrationsApply() {
+  return { applied: [], instructions: DRIZZLE_KIT_INSTRUCTIONS3 };
+}
+async function sqliteMigrationsStatus(db) {
+  const missing = await findMissingTablesForStatus(makeSqliteTableProbe(db));
+  return missing.length > 0 ? { pending: ["0001_init"], applied: [] } : { pending: [], applied: ["0001_init"] };
+}
+async function customersGetByExternalId3(db, externalId) {
+  const rows = await db.select().from(pwCustomers3).where(eq(pwCustomers3.externalId, externalId));
+  return rows[0] ?? null;
+}
+async function customersUpsert3(db, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const rows = await db.insert(pwCustomers3).values({
+      id,
+      externalId: input.externalId,
+      providerIds: {},
+      email: input.email ?? null,
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: pwCustomers3.externalId,
+      set: {
+        email: sql`coalesce(excluded.email, ${pwCustomers3.email})`,
+        updatedAt: now
+      }
+    }).returning();
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (sqlite): customers.upsert returned no row");
+    return row;
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (sqlite): customers.upsert(${JSON.stringify(input.externalId)}) failed.`
+    );
+  }
+}
+async function customersLinkProviderRef3(db, externalId, provider, ref) {
+  const rows = await db.select().from(pwCustomers3).where(eq(pwCustomers3.externalId, externalId));
+  const row = rows[0];
+  if (!row) {
+    throw new PayweaveNotFoundError(
+      `payweave/db/drizzle (sqlite): customers.linkProviderRef: no customer with externalId ${JSON.stringify(externalId)}.`
+    );
+  }
+  const providerIds = { ...row.providerIds, [provider]: ref };
+  await db.update(pwCustomers3).set({ providerIds, updatedAt: /* @__PURE__ */ new Date() }).where(eq(pwCustomers3.externalId, externalId));
+}
+async function plansGetActiveVersion3(db, planId) {
+  const rows = await db.select().from(pwPlans3).where(eq(pwPlans3.planId, planId)).orderBy(sql`${pwPlans3.version} desc`).limit(1);
+  return rows[0] ?? null;
+}
+async function plansListActive3(db) {
+  const latest = db.select({
+    planId: pwPlans3.planId,
+    version: sql`max(${pwPlans3.version})`.as("max_version")
+  }).from(pwPlans3).groupBy(pwPlans3.planId).as("latest");
+  const rows = await db.select({
+    id: pwPlans3.id,
+    planId: pwPlans3.planId,
+    version: pwPlans3.version,
+    group: pwPlans3.group,
+    isDefault: pwPlans3.isDefault,
+    name: pwPlans3.name,
+    priceMinor: pwPlans3.priceMinor,
+    priceCurrency: pwPlans3.priceCurrency,
+    priceInterval: pwPlans3.priceInterval,
+    features: pwPlans3.features,
+    providerRefs: pwPlans3.providerRefs,
+    pushedAt: pwPlans3.pushedAt
+  }).from(pwPlans3).innerJoin(
+    latest,
+    and(eq(latest.planId, pwPlans3.planId), eq(latest.version, pwPlans3.version))
+  );
+  return rows;
+}
+async function plansPushVersion3(db, plan) {
+  const activeRows = await db.select().from(pwPlans3).where(eq(pwPlans3.planId, plan.planId)).orderBy(sql`${pwPlans3.version} desc`).limit(1);
+  const active = activeRows[0] ?? 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 = await db.insert(pwPlans3).values({
+    id,
+    planId: plan.planId,
+    version: nextVersion,
+    group: plan.group,
+    isDefault: plan.isDefault,
+    name: plan.name,
+    priceMinor: plan.priceMinor,
+    priceCurrency: plan.priceCurrency,
+    priceInterval: plan.priceInterval,
+    features: plan.features,
+    providerRefs: plan.providerRefs,
+    pushedAt: now
+  }).returning();
+  const row = rows[0];
+  if (!row) throw new Error("drizzle adapter (sqlite): plans.pushVersion returned no row");
+  return row;
+}
+async function subscriptionsGetActive3(db, customerId, group) {
+  const rows = await db.select().from(pwSubscriptions3).where(
+    and(
+      eq(pwSubscriptions3.customerId, customerId),
+      eq(pwSubscriptions3.group, group),
+      sql`${pwSubscriptions3.status} in ${PW_ACTIVE_SUBSCRIPTION_STATUSES}`
+    )
+  );
+  return rows[0] ?? null;
+}
+async function subscriptionsCreate3(db, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const rows = await db.insert(pwSubscriptions3).values({
+      id,
+      customerId: input.customerId,
+      planId: input.planId,
+      planVersion: input.planVersion,
+      group: input.group,
+      status: input.status,
+      provider: input.provider,
+      providerSubscriptionRef: input.providerSubscriptionRef,
+      currentPeriodStart: input.currentPeriodStart,
+      currentPeriodEnd: input.currentPeriodEnd,
+      cancelAtPeriodEnd: input.cancelAtPeriodEnd,
+      createdAt: now,
+      updatedAt: now
+    }).returning();
+    const row = rows[0];
+    if (!row) throw new Error("drizzle adapter (sqlite): subscriptions.create returned no row");
+    return row;
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (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 subscriptionsUpdate3(db, id, patch) {
+  const set = { updatedAt: /* @__PURE__ */ new Date() };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== void 0) set[key] = value;
+  }
+  try {
+    const rows = await db.update(pwSubscriptions3).set(set).where(eq(pwSubscriptions3.id, id)).returning();
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/drizzle (sqlite): subscriptions.update: no subscription with id ${JSON.stringify(id)}.`
+      );
+    }
+    return row;
+  } catch (error) {
+    if (error instanceof PayweaveNotFoundError) throw error;
+    throw wrapDriverError(
+      error,
+      `payweave/db/drizzle (sqlite): subscriptions.update(${JSON.stringify(id)}) failed.`
+    );
+  }
+}
+async function balancesGet3(db, customerId, featureId, group) {
+  const rows = await db.select().from(pwFeatureBalances3).where(
+    and(
+      eq(pwFeatureBalances3.customerId, customerId),
+      eq(pwFeatureBalances3.featureId, featureId),
+      eq(pwFeatureBalances3.group, group)
+    )
+  );
+  return rows[0] ?? null;
+}
+async function balancesConsume3(db, input) {
+  const existingRows = await db.select().from(pwFeatureBalances3).where(
+    and(
+      eq(pwFeatureBalances3.customerId, input.customerId),
+      eq(pwFeatureBalances3.featureId, input.featureId),
+      eq(pwFeatureBalances3.group, input.group)
+    )
+  );
+  const existingRow = existingRows[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 rows2 = await db.insert(pwFeatureBalances3).values({
+      id,
+      customerId: input.customerId,
+      featureId: input.featureId,
+      group: input.group,
+      used,
+      limit: input.init.limit,
+      resetInterval: input.init.resetInterval,
+      anchor: input.init.anchor,
+      periodStart: new Date(period2.start),
+      periodEnd: new Date(period2.end),
+      planId: input.init.planId,
+      planVersion: input.init.planVersion,
+      updatedAt: input.now
+    }).returning();
+    const row = rows2[0];
+    if (!row) throw new Error("drizzle adapter (sqlite): balances.consume (create) returned no row");
+    return { ...row, applied: applied2 };
+  }
+  const resetDue = nowMs >= existingRow.periodEnd.getTime();
+  const baseUsed = resetDue ? 0 : existingRow.used;
+  const period = resetDue ? currentPeriod(existingRow.anchor.getTime(), existingRow.resetInterval, nowMs) : { start: existingRow.periodStart.getTime(), end: existingRow.periodEnd.getTime() };
+  const remaining = existingRow.limit - baseUsed;
+  const applied = input.conditional !== true || remaining >= input.amount;
+  if (!applied && !resetDue) {
+    return { ...existingRow, applied: false };
+  }
+  const finalUsed = applied ? baseUsed + input.amount : baseUsed;
+  const rows = await db.update(pwFeatureBalances3).set({
+    used: finalUsed,
+    periodStart: new Date(period.start),
+    periodEnd: new Date(period.end),
+    updatedAt: input.now
+  }).where(eq(pwFeatureBalances3.id, existingRow.id)).returning();
+  const updatedRow = rows[0];
+  if (!updatedRow) throw new Error("drizzle adapter (sqlite): balances.consume (update) returned no row");
+  return { ...updatedRow, applied };
+}
+async function balancesResetTo3(db, 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 db.insert(pwFeatureBalances3).values({
+    id,
+    customerId,
+    featureId,
+    group,
+    used: 0,
+    limit: init.limit,
+    resetInterval: init.resetInterval,
+    anchor: init.anchor,
+    periodStart: new Date(period.start),
+    periodEnd: new Date(period.end),
+    planId: init.planId,
+    planVersion: init.planVersion,
+    updatedAt: now
+  }).onConflictDoUpdate({
+    target: [pwFeatureBalances3.customerId, pwFeatureBalances3.featureId, pwFeatureBalances3.group],
+    set: {
+      used: 0,
+      limit: init.limit,
+      resetInterval: init.resetInterval,
+      anchor: init.anchor,
+      periodStart: new Date(period.start),
+      periodEnd: new Date(period.end),
+      planId: init.planId,
+      planVersion: init.planVersion,
+      updatedAt: now
+    }
+  });
+}
+async function webhookEventsClaim3(db, dedupeKey, meta) {
+  const staleClaimAfterMs = meta.staleClaimAfterMs ?? DEFAULT_STALE_CLAIM_AFTER_MS;
+  const staleThreshold = new Date(meta.now.getTime() - staleClaimAfterMs);
+  const rows = await db.insert(pwWebhookEvents3).values({
+    dedupeKey,
+    provider: meta.provider,
+    type: meta.type,
+    receivedAt: meta.now,
+    claimedAt: meta.now,
+    appliedAt: null
+  }).onConflictDoUpdate({
+    target: pwWebhookEvents3.dedupeKey,
+    set: { claimedAt: meta.now },
+    // `and(...)` only returns `undefined` when given zero conditions —
+    // these two are always present, so the non-null assertion is safe
+    // (satisfies `exactOptionalPropertyTypes`, which forbids `| undefined`
+    // on `setWhere` even though `and()`'s own return type allows it).
+    setWhere: and(
+      sql`${pwWebhookEvents3.appliedAt} is null`,
+      sql`${pwWebhookEvents3.claimedAt} <= ${staleThreshold}`
+    )
+  }).returning({ claimedAt: pwWebhookEvents3.claimedAt });
+  const row = rows[0];
+  return row !== void 0 && row.claimedAt !== null && row.claimedAt.getTime() === meta.now.getTime();
+}
+async function webhookEventsMarkApplied3(db, dedupeKey) {
+  await db.update(pwWebhookEvents3).set({ appliedAt: /* @__PURE__ */ new Date() }).where(eq(pwWebhookEvents3.dedupeKey, dedupeKey));
+}
+
+// src/db/drizzle/index.ts
+function looksLikeDrizzleDb(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.select === "function" && typeof candidate.insert === "function" && typeof candidate.update === "function" && typeof candidate.transaction === "function";
+}
+function drizzleAdapter(db, options = {}) {
+  if (!looksLikeDrizzleDb(db)) {
+    throw new PayweaveConfigError(
+      `payweave/db/drizzle: drizzleAdapter(db) expects your own \`drizzle-orm\` database instance (the object returned by e.g. \`drizzle(pool)\`/\`drizzle(client)\`) \u2014 got ${typeof db === "object" && db !== null ? "an object missing select/insert/update/transaction" : typeof db}.`
+    );
+  }
+  const dialect = detectDrizzleDialect(db, options.dialect);
+  switch (dialect) {
+    case "sqlite":
+      return buildSqliteAdapter(db);
+    case "postgres":
+      return buildPostgresAdapter(db);
+    case "mysql":
+      return buildMysqlAdapter(db);
+  }
+}
+
+export { drizzleAdapter, mysqlSchema, pgSchema, sqliteSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map