mcp-scraper 0.40.1 → 0.40.2

package/dist/chunk-GUVKHCKE.js

@@ -0,0 +1,3050 @@
+// src/api/db.ts
+import { createClient } from "@libsql/client/http";
+import { createHash, randomBytes, randomUUID, scryptSync, timingSafeEqual } from "crypto";
+import { z } from "zod";
+
+// src/api/credit-lot-integrity.ts
+var CREDIT_LOTS_EPOCH = "2026-06-26 21:58:03";
+
+// src/api/db.ts
+var DB_URL = process.env.TURSO_DATABASE_URL ?? "file:./paa-api.db";
+var DB_TOKEN = process.env.TURSO_AUTH_TOKEN;
+var _db = null;
+var _rateLimitSchemaReady = false;
+var CORE_SCHEMA_VERSION = "2026-07-28.5";
+var CORE_SCHEMA_TABLES = [
+  "admin_credit_adjustment_events",
+  "admin_credit_adjustments",
+  "billing_authorizations",
+  "billing_credits",
+  "billing_debits",
+  "billing_debit_allocations",
+  "billing_events",
+  "browser_profile_labels",
+  "connected_account_billing",
+  "concurrency_locks",
+  "credit_lot_expirations",
+  "credit_lots",
+  "credit_lot_repairs",
+  "free_credit_refreshes",
+  "harvest_attempts",
+  "inbox_messages",
+  "jobs",
+  "kpo_jobs",
+  "kpo_phase_log",
+  "ledger",
+  "oauth_clients",
+  "oauth_codes",
+  "oauth_tokens",
+  "page_snapshots",
+  "password_reset_tokens",
+  "rate_limits",
+  "request_events",
+  "site_audit_jobs",
+  "site_audit_phase_log",
+  "site_extract_jobs",
+  "site_extract_pages",
+  "stripe_events",
+  "users",
+  "workflow_artifacts",
+  "workflow_runs",
+  "workflow_schedules",
+  "workflow_webhook_deliveries",
+  "workshop_registrations"
+];
+var CORE_SCHEMA_INDEXES = [
+  "admin_credit_adjustment_events_reference",
+  "admin_credit_adjustments_user_created",
+  "billing_authorizations_user_status",
+  "billing_credits_user_status",
+  "billing_debits_user_status",
+  "billing_events_authorization",
+  "billing_events_user_created_at",
+  "concurrency_locks_operation",
+  "concurrency_locks_user_status",
+  "credit_lots_user_active",
+  "credit_lot_repairs_user_applied",
+  "harvest_attempts_job_id",
+  "harvest_attempts_user_created_at",
+  "inbox_messages_user_sent_at",
+  "jobs_created_at_status_user",
+  "jobs_status",
+  "jobs_user_created_at_status",
+  "jobs_user_id",
+  "kpo_jobs_status",
+  "kpo_jobs_user_id",
+  "kpo_phase_log_job_id",
+  "ledger_stripe_pi_unique",
+  "ledger_user_id",
+  "oauth_tokens_identity",
+  "page_snapshots_user_checked_at",
+  "prt_user_id",
+  "request_events_user_created_at",
+  "site_audit_jobs_status",
+  "site_audit_jobs_user_id",
+  "site_audit_phase_log_job_id",
+  "site_extract_jobs_status",
+  "site_extract_jobs_idempotency",
+  "site_extract_jobs_user_id",
+  "site_extract_pages_job_id",
+  "workflow_artifacts_run",
+  "workflow_runs_idempotency",
+  "workflow_runs_schedule",
+  "workflow_runs_user_created",
+  "workflow_schedules_due",
+  "workflow_schedules_user_status",
+  "workflow_webhook_deliveries_run",
+  "workshop_registrations_event_status"
+];
+var CORE_SCHEMA_TRIGGERS = [
+  "credit_lots_bounds_insert",
+  "credit_lots_bounds_update",
+  "credit_lots_one_migration_insert",
+  "credit_lots_one_migration_update"
+];
+var CORE_SCHEMA_COLUMNS = {
+  credit_lots: ["never_expires"],
+  harvest_attempts: ["debug_json"],
+  oauth_tokens: ["replaced_by", "rotated_at"],
+  site_extract_jobs: [
+    "attempted_urls",
+    "successful_urls",
+    "failed_urls",
+    "idempotency_key",
+    "request_fingerprint",
+    "dispatch_attempts",
+    "next_dispatch_at",
+    "dispatch_error",
+    "settlement_attempts",
+    "next_settlement_at",
+    "settlement_error"
+  ],
+  stripe_events: ["attempt_count", "claim_token", "last_error", "status", "updated_at"],
+  users: [
+    "balance_mc",
+    "concurrency_stripe_sub_id",
+    "extra_concurrency_slots",
+    "key_active",
+    "memory_identity",
+    "memory_key",
+    "memory_plan",
+    "memory_provisioned",
+    "memory_subscription_id",
+    "password_hash",
+    "stripe_customer_id",
+    "subscription_concurrency",
+    "subscription_id",
+    "subscription_tier"
+  ],
+  workshop_registrations: ["field_notes_email_id", "reminder_48h_email_id", "reminder_24h_email_id", "reminder_1h_email_id"],
+  workflow_artifacts: ["content"],
+  workflow_runs: ["step_index", "step_log_json", "step_state_json", "total_steps", "webhook_url"]
+};
+function sqlStringList(values) {
+  return values.map((value) => `'${value.replaceAll("'", "''")}'`).join(", ");
+}
+async function hasCurrentCoreSchema(db) {
+  const checks = [
+    `(SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name IN (${sqlStringList(CORE_SCHEMA_TABLES)})) = ${CORE_SCHEMA_TABLES.length}`,
+    `(SELECT COUNT(*) FROM sqlite_master WHERE type = 'index' AND name IN (${sqlStringList(CORE_SCHEMA_INDEXES)})) = ${CORE_SCHEMA_INDEXES.length}`,
+    `(SELECT COUNT(*) FROM sqlite_master WHERE type = 'trigger' AND name IN (${sqlStringList(CORE_SCHEMA_TRIGGERS)})) = ${CORE_SCHEMA_TRIGGERS.length}`,
+    ...Object.entries(CORE_SCHEMA_COLUMNS).map(
+      ([table, columns]) => `(SELECT COUNT(*) FROM pragma_table_info('${table}') WHERE name IN (${sqlStringList(columns)})) = ${columns.length}`
+    )
+  ];
+  const result = await db.execute(`SELECT ${checks.join(" AND ")} AS ready`);
+  return Number(result.rows[0]?.ready ?? 0) === 1;
+}
+async function runIdempotentCoreDataBackfills(db) {
+  await db.execute(`
+    UPDATE site_extract_jobs SET
+      attempted_urls = done_urls,
+      successful_urls = (
+        SELECT COUNT(*) FROM site_extract_pages
+        WHERE job_id = site_extract_jobs.id
+          AND CASE
+            WHEN json_valid(page) = 0 THEN 0
+            WHEN json_extract(page, '$.extractionStatus') IS NOT NULL
+              THEN json_extract(page, '$.extractionStatus') = 'successful'
+            ELSE COALESCE(
+              json_extract(page, '$.status') >= 200
+              AND json_extract(page, '$.status') < 300
+              AND json_extract(page, '$.wordCount') > 0,
+              0
+            )
+          END
+      ),
+      failed_urls = MAX(0, done_urls - (
+        SELECT COUNT(*) FROM site_extract_pages
+        WHERE job_id = site_extract_jobs.id
+          AND CASE
+            WHEN json_valid(page) = 0 THEN 0
+            WHEN json_extract(page, '$.extractionStatus') IS NOT NULL
+              THEN json_extract(page, '$.extractionStatus') = 'successful'
+            ELSE COALESCE(
+              json_extract(page, '$.status') >= 200
+              AND json_extract(page, '$.status') < 300
+              AND json_extract(page, '$.wordCount') > 0,
+              0
+            )
+          END
+      ))
+    WHERE done_urls > 0
+      AND attempted_urls = 0
+      AND successful_urls = 0
+      AND failed_urls = 0
+  `);
+}
+function getDb() {
+  if (!_db) _db = createClient({ url: DB_URL, authToken: DB_TOKEN });
+  return _db;
+}
+function setDbForTesting(client) {
+  _db = client;
+}
+async function migrate() {
+  const db = getDb();
+  let applied;
+  try {
+    applied = await db.execute({
+      sql: "SELECT 1 AS applied FROM schema_migrations WHERE version = ? LIMIT 1",
+      args: [CORE_SCHEMA_VERSION]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    if (!message.includes("no such table") || !message.includes("schema_migrations")) throw error;
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version    TEXT PRIMARY KEY,
+        applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+      )
+    `);
+    applied = { rows: [] };
+  }
+  if (applied.rows.length > 0 && await hasCurrentCoreSchema(db)) {
+    await runIdempotentCoreDataBackfills(db);
+    return;
+  }
+  if (await hasCurrentCoreSchema(db)) {
+    await runIdempotentCoreDataBackfills(db);
+    await db.execute({
+      sql: "INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)",
+      args: [CORE_SCHEMA_VERSION]
+    });
+    return;
+  }
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS users (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      email         TEXT UNIQUE NOT NULL,
+      name          TEXT,
+      api_key       TEXT UNIQUE NOT NULL,
+      password_hash TEXT,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+      active        INTEGER NOT NULL DEFAULT 1
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS jobs (
+      id            TEXT PRIMARY KEY,
+      user_id       INTEGER NOT NULL REFERENCES users(id),
+      status        TEXT NOT NULL DEFAULT 'pending',
+      query         TEXT NOT NULL,
+      options       TEXT NOT NULL,
+      callback_url  TEXT,
+      result        TEXT,
+      error         TEXT,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+      started_at    TEXT,
+      completed_at  TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS jobs_user_id ON jobs(user_id)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS jobs_status ON jobs(status)`);
+  await db.execute(
+    `CREATE INDEX IF NOT EXISTS jobs_created_at_status_user ON jobs(created_at, status, user_id)`
+  );
+  await db.execute(
+    `CREATE INDEX IF NOT EXISTS jobs_user_created_at_status ON jobs(user_id, created_at, status)`
+  );
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS harvest_attempts (
+      id                       TEXT PRIMARY KEY,
+      job_id                   TEXT NOT NULL REFERENCES jobs(id),
+      user_id                  INTEGER NOT NULL REFERENCES users(id),
+      attempt_number           INTEGER NOT NULL,
+      max_attempts             INTEGER NOT NULL,
+      query                    TEXT NOT NULL,
+      location                 TEXT,
+      max_questions            INTEGER NOT NULL,
+      status                   TEXT NOT NULL,
+      outcome                  TEXT,
+      kernel_session_id        TEXT,
+      question_count           INTEGER,
+      duration_ms              INTEGER,
+      error                    TEXT,
+      will_retry               INTEGER,
+      kernel_delete_started    INTEGER NOT NULL DEFAULT 0,
+      kernel_delete_succeeded  INTEGER,
+      kernel_delete_error      TEXT,
+      browser_close_succeeded  INTEGER,
+      browser_close_error      TEXT,
+      debug_json               TEXT,
+      created_at               TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at             TEXT,
+      UNIQUE(job_id, attempt_number)
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS harvest_attempts_job_id ON harvest_attempts(job_id)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS harvest_attempts_user_created_at ON harvest_attempts(user_id, created_at DESC)`);
+  try {
+    await db.execute(`ALTER TABLE harvest_attempts ADD COLUMN debug_json TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN password_hash TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN key_active INTEGER NOT NULL DEFAULT 1`);
+  } catch {
+  }
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS kpo_jobs (
+      id          TEXT    PRIMARY KEY,
+      user_id     INTEGER NOT NULL REFERENCES users(id),
+      status      TEXT    NOT NULL,
+      entity_name TEXT    NOT NULL,
+      entity_type TEXT    NOT NULL,
+      url         TEXT,
+      request     TEXT    NOT NULL,
+      result      TEXT,
+      error       TEXT,
+      created_at  TEXT    NOT NULL DEFAULT (datetime('now')),
+      updated_at  TEXT    NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS kpo_phase_log (
+      id         INTEGER PRIMARY KEY AUTOINCREMENT,
+      job_id     TEXT    NOT NULL REFERENCES kpo_jobs(id),
+      phase      TEXT    NOT NULL,
+      output     TEXT    NOT NULL,
+      created_at TEXT    NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS kpo_jobs_user_id ON kpo_jobs(user_id)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS kpo_jobs_status ON kpo_jobs(status)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS kpo_phase_log_job_id ON kpo_phase_log(job_id)`);
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN stripe_customer_id TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN balance_mc INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN extra_concurrency_slots INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN concurrency_stripe_sub_id TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN subscription_concurrency INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN subscription_tier TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN subscription_id TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN memory_key TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN memory_identity TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN memory_plan TEXT NOT NULL DEFAULT 'free'`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN memory_subscription_id TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE users ADD COLUMN memory_provisioned INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS concurrency_locks (
+      id          TEXT PRIMARY KEY,
+      user_id     INTEGER NOT NULL REFERENCES users(id),
+      operation   TEXT NOT NULL,
+      status      TEXT NOT NULL DEFAULT 'active',
+      acquired_at TEXT NOT NULL DEFAULT (datetime('now')),
+      expires_at  TEXT NOT NULL,
+      released_at TEXT,
+      metadata    TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS concurrency_locks_user_status ON concurrency_locks(user_id, status, expires_at)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS concurrency_locks_operation ON concurrency_locks(operation, status, expires_at)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS ledger (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id     INTEGER NOT NULL REFERENCES users(id),
+      amount_mc   INTEGER NOT NULL,
+      operation   TEXT NOT NULL,
+      description TEXT,
+      stripe_pi   TEXT,
+      created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS ledger_user_id ON ledger(user_id)`);
+  await db.execute(`CREATE UNIQUE INDEX IF NOT EXISTS ledger_stripe_pi_unique ON ledger(stripe_pi) WHERE stripe_pi IS NOT NULL`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS credit_lots (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id      INTEGER NOT NULL REFERENCES users(id),
+      amount_mc    INTEGER NOT NULL,
+      remaining_mc INTEGER NOT NULL,
+      source       TEXT NOT NULL,
+      stripe_pi    TEXT,
+      granted_at   TEXT NOT NULL DEFAULT (datetime('now')),
+      expires_at   TEXT NOT NULL,
+      never_expires INTEGER NOT NULL DEFAULT 0
+    )
+  `);
+  try {
+    await db.execute(`ALTER TABLE credit_lots ADD COLUMN never_expires INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  await db.execute(`CREATE INDEX IF NOT EXISTS credit_lots_user_active ON credit_lots(user_id, expires_at, remaining_mc)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS credit_lot_expirations (
+      lot_id       INTEGER PRIMARY KEY REFERENCES credit_lots(id),
+      user_id      INTEGER NOT NULL REFERENCES users(id),
+      amount_mc    INTEGER NOT NULL,
+      claim_token  TEXT NOT NULL UNIQUE,
+      expired_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`
+    CREATE TRIGGER IF NOT EXISTS credit_lots_bounds_insert
+    BEFORE INSERT ON credit_lots
+    WHEN NEW.amount_mc < 0
+      OR NEW.remaining_mc < 0
+      OR NEW.remaining_mc > NEW.amount_mc
+    BEGIN
+      SELECT RAISE(ABORT, 'invalid credit lot bounds');
+    END
+  `);
+  await db.execute(`
+    CREATE TRIGGER IF NOT EXISTS credit_lots_bounds_update
+    BEFORE UPDATE OF amount_mc, remaining_mc ON credit_lots
+    WHEN NEW.amount_mc < 0
+      OR NEW.remaining_mc < 0
+      OR NEW.remaining_mc > NEW.amount_mc
+    BEGIN
+      SELECT RAISE(ABORT, 'invalid credit lot bounds');
+    END
+  `);
+  await db.execute(`
+    CREATE TRIGGER IF NOT EXISTS credit_lots_one_migration_insert
+    BEFORE INSERT ON credit_lots
+    WHEN NEW.source = 'migration'
+      AND EXISTS (
+        SELECT 1 FROM credit_lots
+        WHERE user_id = NEW.user_id AND source = 'migration'
+      )
+    BEGIN
+      SELECT RAISE(ABORT, 'duplicate migration lot');
+    END
+  `);
+  await db.execute(`
+    CREATE TRIGGER IF NOT EXISTS credit_lots_one_migration_update
+    BEFORE UPDATE OF source, user_id ON credit_lots
+    WHEN NEW.source = 'migration'
+      AND EXISTS (
+        SELECT 1 FROM credit_lots
+        WHERE user_id = NEW.user_id
+          AND source = 'migration'
+          AND id != OLD.id
+      )
+    BEGIN
+      SELECT RAISE(ABORT, 'duplicate migration lot');
+    END
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS credit_lot_repairs (
+      repair_id       TEXT PRIMARY KEY,
+      user_id         INTEGER NOT NULL REFERENCES users(id),
+      report_sha256   TEXT NOT NULL,
+      classification TEXT NOT NULL,
+      before_json     TEXT NOT NULL,
+      plan_json       TEXT NOT NULL,
+      after_json      TEXT,
+      status          TEXT NOT NULL DEFAULT 'claimed',
+      created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+      applied_at      TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS credit_lot_repairs_user_applied ON credit_lot_repairs(user_id, applied_at)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS free_credit_refreshes (
+      user_id    INTEGER NOT NULL REFERENCES users(id),
+      month      TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (user_id, month)
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS billing_authorizations (
+      id                TEXT PRIMARY KEY,
+      user_id           INTEGER NOT NULL REFERENCES users(id),
+      idempotency_key   TEXT NOT NULL UNIQUE,
+      billing_class     TEXT NOT NULL,
+      status            TEXT NOT NULL,
+      minimum_amount_mc INTEGER NOT NULL,
+      maximum_amount_mc INTEGER NOT NULL,
+      token_hash        TEXT NOT NULL,
+      metadata          TEXT,
+      expires_at        TEXT NOT NULL,
+      created_at        TEXT NOT NULL DEFAULT (datetime('now')),
+      settled_at        TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS billing_authorizations_user_status ON billing_authorizations(user_id, status, expires_at)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS billing_events (
+      id                 TEXT PRIMARY KEY,
+      user_id            INTEGER NOT NULL REFERENCES users(id),
+      authorization_id   TEXT REFERENCES billing_authorizations(id),
+      idempotency_key    TEXT NOT NULL UNIQUE,
+      billing_class      TEXT NOT NULL,
+      source_surface     TEXT NOT NULL,
+      status             TEXT NOT NULL,
+      amount_mc          INTEGER NOT NULL DEFAULT 0,
+      raw_cost_usd_nanos INTEGER,
+      multiplier_bps     INTEGER,
+      input_tokens       INTEGER,
+      output_tokens      INTEGER,
+      cached_tokens      INTEGER,
+      model_steps        INTEGER,
+      metadata           TEXT,
+      created_at         TEXT NOT NULL DEFAULT (datetime('now')),
+      settled_at         TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS billing_events_user_created_at ON billing_events(user_id, created_at DESC)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS billing_events_authorization ON billing_events(authorization_id)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS billing_debits (
+      idempotency_key TEXT PRIMARY KEY,
+      user_id         INTEGER NOT NULL REFERENCES users(id),
+      amount_mc       INTEGER NOT NULL,
+      operation       TEXT NOT NULL,
+      description     TEXT,
+      status          TEXT NOT NULL DEFAULT 'claimed',
+      created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+      applied_at      TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS billing_debits_user_status ON billing_debits(user_id, status)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS billing_debit_allocations (
+      debit_idempotency_key TEXT NOT NULL REFERENCES billing_debits(idempotency_key),
+      lot_id                INTEGER NOT NULL REFERENCES credit_lots(id),
+      user_id               INTEGER NOT NULL REFERENCES users(id),
+      amount_mc             INTEGER NOT NULL,
+      expires_at            TEXT NOT NULL,
+      PRIMARY KEY (debit_idempotency_key, lot_id)
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS connected_account_billing (
+      user_id                     INTEGER PRIMARY KEY REFERENCES users(id),
+      stripe_subscription_id      TEXT,
+      stripe_subscription_item_id TEXT,
+      price_id                    TEXT,
+      quantity                    INTEGER NOT NULL DEFAULT 0,
+      status                      TEXT NOT NULL DEFAULT 'pending',
+      last_error_code             TEXT,
+      checked_at                  TEXT NOT NULL DEFAULT (datetime('now')),
+      synced_at                   TEXT,
+      updated_at                  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS billing_credits (
+      idempotency_key TEXT PRIMARY KEY,
+      user_id         INTEGER NOT NULL REFERENCES users(id),
+      amount_mc       INTEGER NOT NULL,
+      operation       TEXT NOT NULL,
+      description     TEXT,
+      status          TEXT NOT NULL DEFAULT 'claimed',
+      created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+      applied_at      TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS billing_credits_user_status ON billing_credits(user_id, status)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS admin_credit_adjustments (
+      reference   TEXT PRIMARY KEY,
+      user_id     INTEGER NOT NULL REFERENCES users(id),
+      direction   TEXT NOT NULL,
+      amount_mc   INTEGER NOT NULL,
+      reason      TEXT NOT NULL,
+      actor       TEXT NOT NULL,
+      status      TEXT NOT NULL DEFAULT 'applied',
+      created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at  TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS admin_credit_adjustments_user_created ON admin_credit_adjustments(user_id, created_at)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS admin_credit_adjustment_events (
+      id             INTEGER PRIMARY KEY AUTOINCREMENT,
+      reference      TEXT NOT NULL REFERENCES admin_credit_adjustments(reference),
+      seq            INTEGER NOT NULL,
+      kind           TEXT NOT NULL,
+      from_amount_mc INTEGER,
+      to_amount_mc   INTEGER,
+      from_reason    TEXT,
+      to_reason      TEXT,
+      moved_mc       INTEGER NOT NULL DEFAULT 0,
+      actor          TEXT NOT NULL,
+      created_at     TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE (reference, seq)
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS admin_credit_adjustment_events_reference ON admin_credit_adjustment_events(reference)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS site_audit_jobs (
+      id            TEXT    PRIMARY KEY,
+      user_id       INTEGER,
+      status        TEXT    DEFAULT 'pending',
+      client_domain TEXT,
+      session_path  TEXT,
+      request       TEXT,
+      result        TEXT,
+      error         TEXT,
+      created_at    TEXT    DEFAULT (datetime('now')),
+      updated_at    TEXT    DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS site_audit_phase_log (
+      id             INTEGER PRIMARY KEY AUTOINCREMENT,
+      job_id         TEXT    REFERENCES site_audit_jobs(id),
+      phase          TEXT,
+      completed_at   TEXT    DEFAULT (datetime('now')),
+      output_summary TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS site_audit_jobs_user_id ON site_audit_jobs(user_id)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS site_audit_jobs_status ON site_audit_jobs(status)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS site_audit_phase_log_job_id ON site_audit_phase_log(job_id)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS site_extract_jobs (
+      id            TEXT    PRIMARY KEY,
+      user_id       INTEGER,
+      status        TEXT    DEFAULT 'pending',
+      start_url     TEXT,
+      options       TEXT,
+      total_urls    INTEGER DEFAULT 0,
+      done_urls     INTEGER DEFAULT 0,
+      attempted_urls INTEGER DEFAULT 0,
+      successful_urls INTEGER DEFAULT 0,
+      failed_urls   INTEGER DEFAULT 0,
+      idempotency_key TEXT,
+      request_fingerprint TEXT,
+      dispatch_attempts INTEGER DEFAULT 0,
+      next_dispatch_at TEXT,
+      dispatch_error TEXT,
+      settlement_attempts INTEGER DEFAULT 0,
+      next_settlement_at TEXT,
+      settlement_error TEXT,
+      artifacts     TEXT,
+      error         TEXT,
+      billed_mc     INTEGER,
+      created_at    TEXT    DEFAULT (datetime('now')),
+      updated_at    TEXT    DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS site_extract_pages (
+      job_id     TEXT,
+      url        TEXT,
+      page       TEXT,
+      PRIMARY KEY (job_id, url)
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS site_extract_jobs_user_id ON site_extract_jobs(user_id)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS site_extract_jobs_status ON site_extract_jobs(status)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS site_extract_pages_job_id ON site_extract_pages(job_id)`);
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN attempted_urls INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN successful_urls INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN failed_urls INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN idempotency_key TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN request_fingerprint TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN dispatch_attempts INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN next_dispatch_at TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN dispatch_error TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN settlement_attempts INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN next_settlement_at TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN settlement_error TEXT`);
+  } catch {
+  }
+  await db.execute(`CREATE UNIQUE INDEX IF NOT EXISTS site_extract_jobs_idempotency ON site_extract_jobs(user_id, idempotency_key) WHERE idempotency_key IS NOT NULL`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS password_reset_tokens (
+      token      TEXT    PRIMARY KEY,
+      user_id    INTEGER NOT NULL REFERENCES users(id),
+      expires_at TEXT    NOT NULL,
+      used       INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT    NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS prt_user_id ON password_reset_tokens(user_id)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS rate_limits (
+      scope        TEXT    NOT NULL,
+      key_hash     TEXT    NOT NULL,
+      window_start INTEGER NOT NULL,
+      count        INTEGER NOT NULL DEFAULT 0,
+      updated_at   TEXT    NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (scope, key_hash, window_start)
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS request_events (
+      id           TEXT PRIMARY KEY,
+      user_id      INTEGER NOT NULL REFERENCES users(id),
+      source       TEXT NOT NULL,
+      status       TEXT NOT NULL,
+      query        TEXT NOT NULL,
+      location     TEXT,
+      result_count INTEGER,
+      result       TEXT,
+      error        TEXT,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS request_events_user_created_at ON request_events(user_id, created_at DESC)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_schedules (
+      id             TEXT PRIMARY KEY,
+      user_id        INTEGER NOT NULL REFERENCES users(id),
+      workflow_id    TEXT NOT NULL,
+      name           TEXT NOT NULL,
+      input_json     TEXT NOT NULL,
+      cadence        TEXT NOT NULL,
+      cron_expr      TEXT,
+      timezone       TEXT NOT NULL DEFAULT 'UTC',
+      webhook_url    TEXT,
+      status         TEXT NOT NULL DEFAULT 'active',
+      next_run_at    TEXT,
+      last_run_at    TEXT,
+      created_at     TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at     TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_schedules_user_status ON workflow_schedules(user_id, status, created_at DESC)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_schedules_due ON workflow_schedules(status, next_run_at)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id              TEXT PRIMARY KEY,
+      user_id         INTEGER NOT NULL REFERENCES users(id),
+      schedule_id     TEXT,
+      workflow_id     TEXT NOT NULL,
+      input_json      TEXT NOT NULL,
+      status          TEXT NOT NULL DEFAULT 'queued',
+      manifest_json   TEXT,
+      error_message   TEXT,
+      queued_at       TEXT NOT NULL DEFAULT (datetime('now')),
+      started_at      TEXT,
+      completed_at    TEXT,
+      idempotency_key TEXT,
+      step_index      INTEGER NOT NULL DEFAULT 0,
+      total_steps     INTEGER,
+      step_state_json TEXT,
+      step_log_json   TEXT,
+      webhook_url     TEXT
+    )
+  `);
+  try {
+    await db.execute(`ALTER TABLE workflow_runs ADD COLUMN step_index INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE workflow_runs ADD COLUMN total_steps INTEGER`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE workflow_runs ADD COLUMN step_state_json TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE workflow_runs ADD COLUMN step_log_json TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE workflow_runs ADD COLUMN webhook_url TEXT`);
+  } catch {
+  }
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_runs_user_created ON workflow_runs(user_id, queued_at DESC)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_runs_schedule ON workflow_runs(schedule_id, queued_at DESC)`);
+  await db.execute(`CREATE UNIQUE INDEX IF NOT EXISTS workflow_runs_idempotency ON workflow_runs(idempotency_key) WHERE idempotency_key IS NOT NULL`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_artifacts (
+      id           TEXT PRIMARY KEY,
+      run_id       TEXT NOT NULL REFERENCES workflow_runs(id),
+      user_id      INTEGER NOT NULL REFERENCES users(id),
+      kind         TEXT NOT NULL,
+      label        TEXT NOT NULL,
+      path         TEXT NOT NULL,
+      content_type TEXT NOT NULL,
+      bytes        INTEGER,
+      rows_count   INTEGER,
+      content      TEXT,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  try {
+    await db.execute(`ALTER TABLE workflow_artifacts ADD COLUMN content TEXT`);
+  } catch {
+  }
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_artifacts_run ON workflow_artifacts(run_id)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workflow_webhook_deliveries (
+      id           TEXT PRIMARY KEY,
+      run_id       TEXT NOT NULL REFERENCES workflow_runs(id),
+      schedule_id  TEXT,
+      user_id      INTEGER NOT NULL REFERENCES users(id),
+      webhook_url  TEXT NOT NULL,
+      status       TEXT NOT NULL,
+      attempts     INTEGER NOT NULL DEFAULT 0,
+      last_error   TEXT,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+      delivered_at TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS workflow_webhook_deliveries_run ON workflow_webhook_deliveries(run_id)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS stripe_events (
+      event_id      TEXT PRIMARY KEY,
+      status        TEXT NOT NULL DEFAULT 'processed',
+      attempt_count INTEGER NOT NULL DEFAULT 1,
+      claim_token   TEXT,
+      last_error    TEXT,
+      processed_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  for (const col of [
+    `status TEXT NOT NULL DEFAULT 'processed'`,
+    "attempt_count INTEGER NOT NULL DEFAULT 1",
+    "claim_token TEXT",
+    "last_error TEXT",
+    "updated_at TEXT"
+  ]) {
+    try {
+      await db.execute(`ALTER TABLE stripe_events ADD COLUMN ${col}`);
+    } catch {
+    }
+  }
+  await db.execute(`
+    UPDATE stripe_events
+    SET updated_at = COALESCE(updated_at, processed_at),
+        status = COALESCE(status, 'processed'),
+        attempt_count = MAX(1, COALESCE(attempt_count, 1))
+    WHERE updated_at IS NULL
+       OR status IS NULL
+       OR attempt_count IS NULL
+       OR attempt_count < 1
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS oauth_clients (
+      client_id     TEXT PRIMARY KEY,
+      redirect_uris TEXT NOT NULL,
+      name          TEXT,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS oauth_codes (
+      code           TEXT PRIMARY KEY,
+      client_id      TEXT NOT NULL,
+      redirect_uri   TEXT NOT NULL,
+      code_challenge TEXT NOT NULL,
+      identity       TEXT NOT NULL,
+      scope          TEXT NOT NULL,
+      resource       TEXT,
+      expires_at     TEXT NOT NULL,
+      created_at     TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS oauth_tokens (
+      refresh_token TEXT PRIMARY KEY,
+      client_id     TEXT NOT NULL,
+      identity      TEXT NOT NULL,
+      scope         TEXT NOT NULL,
+      resource      TEXT,
+      expires_at    TEXT NOT NULL,
+      revoked       INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS oauth_tokens_identity ON oauth_tokens(identity)`);
+  for (const col of ["replaced_by TEXT", "rotated_at TEXT"]) {
+    try {
+      await db.execute(`ALTER TABLE oauth_tokens ADD COLUMN ${col}`);
+    } catch {
+    }
+  }
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS page_snapshots (
+      user_id       INTEGER NOT NULL REFERENCES users(id),
+      url           TEXT    NOT NULL,
+      content_hash  TEXT    NOT NULL,
+      content       TEXT    NOT NULL,
+      title         TEXT,
+      content_bytes INTEGER NOT NULL,
+      truncated     INTEGER NOT NULL DEFAULT 0,
+      checked_at    TEXT    NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (user_id, url)
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS page_snapshots_user_checked_at ON page_snapshots(user_id, checked_at DESC)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS inbox_messages (
+      id         TEXT    PRIMARY KEY,
+      user_id    INTEGER NOT NULL REFERENCES users(id),
+      subject    TEXT    NOT NULL,
+      body_md    TEXT    NOT NULL,
+      source     TEXT    NOT NULL DEFAULT 'operator',
+      sent_at    TEXT    NOT NULL DEFAULT (datetime('now')),
+      opened_at  TEXT,
+      deleted_at TEXT
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS inbox_messages_user_sent_at ON inbox_messages(user_id, sent_at DESC)`);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS workshop_registrations (
+      id                    TEXT PRIMARY KEY,
+      event_slug            TEXT NOT NULL,
+      email                 TEXT NOT NULL,
+      first_name            TEXT NOT NULL,
+      last_name             TEXT,
+      status                TEXT NOT NULL,
+      zoom_registrant_id    TEXT,
+      zoom_join_url         TEXT,
+      resend_contact_id     TEXT,
+      confirmation_email_id TEXT,
+      field_notes_email_id  TEXT,
+      reminder_48h_email_id TEXT,
+      reminder_24h_email_id TEXT,
+      reminder_1h_email_id  TEXT,
+      last_error            TEXT,
+      registered_at         TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at            TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(event_slug, email)
+    )
+  `);
+  for (const col of ["field_notes_email_id TEXT", "reminder_48h_email_id TEXT", "reminder_24h_email_id TEXT", "reminder_1h_email_id TEXT"]) {
+    try {
+      await db.execute(`ALTER TABLE workshop_registrations ADD COLUMN ${col}`);
+    } catch {
+    }
+  }
+  await db.execute(`
+    CREATE INDEX IF NOT EXISTS workshop_registrations_event_status
+    ON workshop_registrations(event_slug, status, registered_at)
+  `);
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS browser_profile_labels (
+      user_id    INTEGER NOT NULL REFERENCES users(id),
+      profile    TEXT    NOT NULL,
+      label      TEXT    NOT NULL,
+      created_at TEXT    NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT,
+      PRIMARY KEY (user_id, profile)
+    )
+  `);
+  if (!await hasCurrentCoreSchema(db)) {
+    throw new Error("core schema migration finished without all required tables, indexes, and columns");
+  }
+  await runIdempotentCoreDataBackfills(db);
+  await db.execute({
+    sql: "INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)",
+    args: [CORE_SCHEMA_VERSION]
+  });
+}
+async function registerClient(clientId, redirectUris, name) {
+  await getDb().execute({
+    sql: "INSERT INTO oauth_clients (client_id, redirect_uris, name) VALUES (?, ?, ?)",
+    args: [clientId, JSON.stringify(redirectUris), name]
+  });
+}
+async function getClient(clientId) {
+  const res = await getDb().execute({ sql: "SELECT * FROM oauth_clients WHERE client_id = ?", args: [clientId] });
+  const row = res.rows[0];
+  if (!row) return void 0;
+  let uris = [];
+  try {
+    const parsed = JSON.parse(String(row.redirect_uris));
+    if (Array.isArray(parsed)) uris = parsed.filter((u) => typeof u === "string");
+  } catch {
+    uris = [];
+  }
+  return {
+    client_id: String(row.client_id),
+    redirect_uris: uris,
+    name: row.name != null ? String(row.name) : null,
+    created_at: String(row.created_at)
+  };
+}
+async function putCode(code) {
+  await getDb().execute({
+    sql: "INSERT INTO oauth_codes (code, client_id, redirect_uri, code_challenge, identity, scope, resource, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+    args: [code.code, code.client_id, code.redirect_uri, code.code_challenge, code.identity, code.scope, code.resource, code.expires_at]
+  });
+}
+async function consumeCode(code) {
+  const db = getDb();
+  const res = await db.execute({ sql: "SELECT * FROM oauth_codes WHERE code = ?", args: [code] });
+  const row = res.rows[0];
+  await db.execute({ sql: "DELETE FROM oauth_codes WHERE code = ?", args: [code] });
+  if (!row) return void 0;
+  return {
+    code: String(row.code),
+    client_id: String(row.client_id),
+    redirect_uri: String(row.redirect_uri),
+    code_challenge: String(row.code_challenge),
+    identity: String(row.identity),
+    scope: String(row.scope),
+    resource: row.resource != null ? String(row.resource) : null,
+    expires_at: String(row.expires_at)
+  };
+}
+async function putRefresh(token) {
+  await getDb().execute({
+    sql: "INSERT INTO oauth_tokens (refresh_token, client_id, identity, scope, resource, expires_at, revoked) VALUES (?, ?, ?, ?, ?, ?, 0)",
+    args: [token.refresh_token, token.client_id, token.identity, token.scope, token.resource, token.expires_at]
+  });
+}
+async function getRefresh(refreshToken) {
+  const res = await getDb().execute({ sql: "SELECT * FROM oauth_tokens WHERE refresh_token = ?", args: [refreshToken] });
+  const row = res.rows[0];
+  if (!row) return void 0;
+  return {
+    refresh_token: String(row.refresh_token),
+    client_id: String(row.client_id),
+    identity: String(row.identity),
+    scope: String(row.scope),
+    resource: row.resource != null ? String(row.resource) : null,
+    expires_at: String(row.expires_at),
+    revoked: Number(row.revoked ?? 0),
+    replaced_by: row.replaced_by != null ? String(row.replaced_by) : null,
+    rotated_at: row.rotated_at != null ? String(row.rotated_at) : null
+  };
+}
+async function revokeRefresh(refreshToken) {
+  await getDb().execute({ sql: "UPDATE oauth_tokens SET revoked = 1 WHERE refresh_token = ?", args: [refreshToken] });
+}
+async function rotateRefresh(oldToken, next) {
+  await putRefresh(next);
+  await getDb().execute({
+    sql: "UPDATE oauth_tokens SET revoked = 1, replaced_by = ?, rotated_at = ? WHERE refresh_token = ?",
+    args: [next.refresh_token, (/* @__PURE__ */ new Date()).toISOString(), oldToken]
+  });
+}
+async function claimStripeEvent(eventId) {
+  const token = randomUUID();
+  const claimed = await getDb().execute({
+    sql: `INSERT INTO stripe_events
+            (event_id, status, attempt_count, claim_token, last_error, processed_at, updated_at)
+          VALUES (?, 'processing', 1, ?, NULL, datetime('now'), datetime('now'))
+          ON CONFLICT(event_id) DO UPDATE SET
+            status = 'processing',
+            attempt_count = stripe_events.attempt_count + 1,
+            claim_token = excluded.claim_token,
+            last_error = NULL,
+            updated_at = datetime('now')
+          WHERE stripe_events.status = 'failed'
+             OR (
+               stripe_events.status = 'processing'
+               AND stripe_events.updated_at <= datetime('now', '-10 minutes')
+             )`,
+    args: [eventId, token]
+  });
+  if (claimed.rowsAffected > 0) return { state: "claimed", token };
+  const current = await getDb().execute({
+    sql: "SELECT status FROM stripe_events WHERE event_id = ? LIMIT 1",
+    args: [eventId]
+  });
+  return { state: String(current.rows[0]?.status) === "processed" ? "processed" : "processing" };
+}
+async function completeStripeEvent(eventId, token) {
+  const result = await getDb().execute({
+    sql: `UPDATE stripe_events
+          SET status = 'processed',
+              claim_token = NULL,
+              last_error = NULL,
+              processed_at = datetime('now'),
+              updated_at = datetime('now')
+          WHERE event_id = ? AND status = 'processing' AND claim_token = ?`,
+    args: [eventId, token]
+  });
+  return result.rowsAffected === 1;
+}
+async function failStripeEvent(eventId, token, error) {
+  const result = await getDb().execute({
+    sql: `UPDATE stripe_events
+          SET status = 'failed',
+              claim_token = NULL,
+              last_error = ?,
+              updated_at = datetime('now')
+          WHERE event_id = ? AND status = 'processing' AND claim_token = ?`,
+    args: [error.slice(0, 500), eventId, token]
+  });
+  return result.rowsAffected === 1;
+}
+async function stripeEventAlreadyProcessed(eventId) {
+  const res = await getDb().execute({
+    sql: `SELECT 1 FROM stripe_events WHERE event_id = ? AND status = 'processed' LIMIT 1`,
+    args: [eventId]
+  });
+  return res.rows.length > 0;
+}
+function generateApiKey() {
+  return "sk_" + randomBytes(24).toString("hex");
+}
+function hashPassword(password) {
+  const salt = randomBytes(16).toString("hex");
+  const hash = scryptSync(password, salt, 64);
+  return `${salt}:${hash.toString("hex")}`;
+}
+function verifyPassword(password, stored) {
+  const [salt, hash] = stored.split(":");
+  const hashBuf = Buffer.from(hash, "hex");
+  const derived = scryptSync(password, salt, 64);
+  return timingSafeEqual(hashBuf, derived);
+}
+function rowToUser(row) {
+  return {
+    id: Number(row.id),
+    email: String(row.email),
+    name: row.name != null ? String(row.name) : null,
+    api_key: String(row.api_key),
+    key_active: Number(row.key_active ?? 1),
+    password_hash: row.password_hash != null ? String(row.password_hash) : null,
+    created_at: String(row.created_at),
+    active: Number(row.active),
+    stripe_customer_id: row.stripe_customer_id != null ? String(row.stripe_customer_id) : null,
+    balance_mc: Number(row.balance_mc ?? 0),
+    extra_concurrency_slots: Number(row.extra_concurrency_slots ?? 0),
+    concurrency_stripe_sub_id: row.concurrency_stripe_sub_id != null ? String(row.concurrency_stripe_sub_id) : null,
+    subscription_concurrency: Number(row.subscription_concurrency ?? 0),
+    subscription_tier: row.subscription_tier != null ? String(row.subscription_tier) : null,
+    subscription_id: row.subscription_id != null ? String(row.subscription_id) : null,
+    memory_plan: row.memory_plan != null ? String(row.memory_plan) : "free",
+    memory_subscription_id: row.memory_subscription_id != null ? String(row.memory_subscription_id) : null,
+    memory_provisioned: Number(row.memory_provisioned ?? 0)
+  };
+}
+async function getUserByEmail(email) {
+  const res = await getDb().execute({ sql: "SELECT * FROM users WHERE email = ? AND active = 1", args: [email] });
+  return res.rows[0] ? rowToUser(res.rows[0]) : void 0;
+}
+async function getUserByApiKey(api_key) {
+  const res = await getDb().execute({ sql: "SELECT * FROM users WHERE api_key = ? AND active = 1 AND key_active = 1", args: [api_key] });
+  return res.rows[0] ? rowToUser(res.rows[0]) : void 0;
+}
+async function getUserById(id) {
+  const res = await getDb().execute({ sql: "SELECT * FROM users WHERE id = ? AND active = 1", args: [id] });
+  return res.rows[0] ? rowToUser(res.rows[0]) : void 0;
+}
+async function getUserMemoryCreds(id) {
+  const res = await getDb().execute({ sql: "SELECT memory_key, memory_identity FROM users WHERE id = ?", args: [id] });
+  const row = res.rows[0];
+  return {
+    memory_key: row?.memory_key != null ? String(row.memory_key) : null,
+    memory_identity: row?.memory_identity != null ? String(row.memory_identity) : null
+  };
+}
+async function setUserMemoryCreds(id, memoryKeyEncrypted, memoryIdentity) {
+  await getDb().execute({ sql: "UPDATE users SET memory_key = ?, memory_identity = ? WHERE id = ?", args: [memoryKeyEncrypted, memoryIdentity, id] });
+}
+async function setPassword(id, password) {
+  await getDb().execute({ sql: "UPDATE users SET password_hash = ? WHERE id = ?", args: [hashPassword(password), id] });
+}
+async function getUserStats(userId) {
+  const db = getDb();
+  const [totR, doneR, failR, tqR, luR] = await Promise.all([
+    db.execute({ sql: "SELECT COUNT(*) as n FROM jobs WHERE user_id = ?", args: [userId] }),
+    db.execute({ sql: "SELECT COUNT(*) as n FROM jobs WHERE user_id = ? AND status = 'done'", args: [userId] }),
+    db.execute({ sql: "SELECT COUNT(*) as n FROM jobs WHERE user_id = ? AND status = 'failed'", args: [userId] }),
+    db.execute({ sql: "SELECT COALESCE(SUM(json_extract(result, '$.totalQuestions')), 0) as n FROM jobs WHERE user_id = ? AND status = 'done'", args: [userId] }),
+    db.execute({ sql: "SELECT MAX(created_at) as t FROM jobs WHERE user_id = ?", args: [userId] })
+  ]);
+  return {
+    total: Number(totR.rows[0]?.n ?? 0),
+    done: Number(doneR.rows[0]?.n ?? 0),
+    failed: Number(failR.rows[0]?.n ?? 0),
+    totalQuestions: Number(tqR.rows[0]?.n ?? 0),
+    lastUsed: luR.rows[0]?.t != null ? String(luR.rows[0].t) : null
+  };
+}
+async function createUser(email, name, password, stripeCustomerId) {
+  const db = getDb();
+  const api_key = generateApiKey();
+  const plainPassword = password ?? randomBytes(6).toString("hex");
+  const password_hash = hashPassword(plainPassword);
+  const result = await db.execute({
+    sql: "INSERT INTO users (email, name, api_key, password_hash, stripe_customer_id) VALUES (?, ?, ?, ?, ?)",
+    args: [email, name ?? null, api_key, password_hash, stripeCustomerId ?? null]
+  });
+  return { id: result.lastInsertRowid, email, name, api_key, password: plainPassword };
+}
+async function checkRateLimit(scope, key, limit, windowSeconds) {
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const windowStart = Math.floor(nowSeconds / windowSeconds) * windowSeconds;
+  const keyHash = createHash("sha256").update(key).digest("hex");
+  const db = getDb();
+  if (!_rateLimitSchemaReady) {
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS rate_limits (
+        scope        TEXT    NOT NULL,
+        key_hash     TEXT    NOT NULL,
+        window_start INTEGER NOT NULL,
+        count        INTEGER NOT NULL DEFAULT 0,
+        updated_at   TEXT    NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (scope, key_hash, window_start)
+      )
+    `);
+    _rateLimitSchemaReady = true;
+  }
+  await db.execute({
+    sql: `
+      INSERT INTO rate_limits (scope, key_hash, window_start, count)
+      VALUES (?, ?, ?, 1)
+      ON CONFLICT(scope, key_hash, window_start)
+      DO UPDATE SET count = count + 1, updated_at = datetime('now')
+    `,
+    args: [scope, keyHash, windowStart]
+  });
+  const res = await db.execute({
+    sql: "SELECT count FROM rate_limits WHERE scope = ? AND key_hash = ? AND window_start = ?",
+    args: [scope, keyHash, windowStart]
+  });
+  const count = Number(res.rows[0]?.count ?? 1);
+  return {
+    allowed: count <= limit,
+    count,
+    remaining: Math.max(0, limit - count),
+    resetSeconds: Math.max(1, windowStart + windowSeconds - nowSeconds)
+  };
+}
+async function createPasswordResetToken(userId) {
+  const token = randomBytes(32).toString("hex");
+  const tokenHash = createHash("sha256").update(token).digest("hex");
+  const expiresAt = new Date(Date.now() + 60 * 60 * 1e3).toISOString();
+  await getDb().execute({
+    sql: "INSERT INTO password_reset_tokens (token, user_id, expires_at) VALUES (?, ?, ?)",
+    args: [tokenHash, userId, expiresAt]
+  });
+  return token;
+}
+async function consumePasswordResetToken(token) {
+  const db = getDb();
+  const tokenHash = createHash("sha256").update(token).digest("hex");
+  const res = await db.execute({
+    sql: "SELECT user_id, expires_at, used FROM password_reset_tokens WHERE token = ?",
+    args: [tokenHash]
+  });
+  const row = res.rows[0];
+  if (!row) return null;
+  if (Number(row.used)) return null;
+  if (new Date(String(row.expires_at)) < /* @__PURE__ */ new Date()) return null;
+  await db.execute({ sql: "UPDATE password_reset_tokens SET used = 1 WHERE token = ?", args: [tokenHash] });
+  return Number(row.user_id);
+}
+async function rotateApiKey(userId) {
+  const newKey = generateApiKey();
+  await getDb().execute({ sql: "UPDATE users SET api_key = ?, key_active = 1 WHERE id = ?", args: [newKey, userId] });
+  return newKey;
+}
+async function revokeApiKey(userId) {
+  await getDb().execute({ sql: "UPDATE users SET key_active = 0 WHERE id = ?", args: [userId] });
+}
+async function listUsers() {
+  const res = await getDb().execute("SELECT id, email, name, created_at, active FROM users ORDER BY created_at DESC");
+  return res.rows.map((r) => rowToUser({ ...r, api_key: "", key_active: 1 }));
+}
+async function deactivateUser(id) {
+  await getDb().execute({ sql: "UPDATE users SET active = 0 WHERE id = ?", args: [id] });
+}
+function rowToRawJob(row) {
+  return {
+    id: String(row.id),
+    user_id: Number(row.user_id),
+    status: String(row.status),
+    query: String(row.query),
+    options: String(row.options),
+    callback_url: row.callback_url != null ? String(row.callback_url) : null,
+    result: row.result != null ? String(row.result) : null,
+    error: row.error != null ? String(row.error) : null,
+    created_at: String(row.created_at),
+    started_at: row.started_at != null ? String(row.started_at) : null,
+    completed_at: row.completed_at != null ? String(row.completed_at) : null
+  };
+}
+function nullableBoolean(value) {
+  return value == null ? null : Number(value) === 1;
+}
+function parseNullableJson(value) {
+  if (value == null) return null;
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    return null;
+  }
+}
+function rowToHarvestAttemptLog(row) {
+  return {
+    id: String(row.id),
+    job_id: String(row.job_id),
+    user_id: Number(row.user_id),
+    attempt_number: Number(row.attempt_number),
+    max_attempts: Number(row.max_attempts),
+    query: String(row.query),
+    location: row.location != null ? String(row.location) : null,
+    max_questions: Number(row.max_questions),
+    status: String(row.status),
+    outcome: row.outcome != null ? String(row.outcome) : null,
+    kernel_session_id: row.kernel_session_id != null ? String(row.kernel_session_id) : null,
+    question_count: row.question_count != null ? Number(row.question_count) : null,
+    duration_ms: row.duration_ms != null ? Number(row.duration_ms) : null,
+    error: row.error != null ? String(row.error) : null,
+    will_retry: nullableBoolean(row.will_retry),
+    kernel_delete_started: Number(row.kernel_delete_started ?? 0) === 1,
+    kernel_delete_succeeded: nullableBoolean(row.kernel_delete_succeeded),
+    kernel_delete_error: row.kernel_delete_error != null ? String(row.kernel_delete_error) : null,
+    browser_close_succeeded: nullableBoolean(row.browser_close_succeeded),
+    browser_close_error: row.browser_close_error != null ? String(row.browser_close_error) : null,
+    debug: parseNullableJson(row.debug_json),
+    created_at: String(row.created_at),
+    completed_at: row.completed_at != null ? String(row.completed_at) : null
+  };
+}
+function deserialize(raw) {
+  return {
+    ...raw,
+    options: JSON.parse(raw.options),
+    result: raw.result ? JSON.parse(raw.result) : null
+  };
+}
+async function createJob(userId, query, options, callbackUrl) {
+  const id = randomUUID();
+  await getDb().execute({
+    sql: "INSERT INTO jobs (id, user_id, query, options, callback_url) VALUES (?, ?, ?, ?, ?)",
+    args: [id, userId, query, JSON.stringify(options), callbackUrl ?? null]
+  });
+  return id;
+}
+async function createRunningJob(userId, query, options) {
+  const id = randomUUID();
+  await getDb().execute({
+    sql: `INSERT INTO jobs (id, user_id, query, options, status, started_at) VALUES (?, ?, ?, ?, 'running', datetime('now'))`,
+    args: [id, userId, query, JSON.stringify(options)]
+  });
+  return id;
+}
+async function startHarvestAttempt(input) {
+  await getDb().execute({
+    sql: `
+      INSERT INTO harvest_attempts (
+        id, job_id, user_id, attempt_number, max_attempts, query, location, max_questions, status, created_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'running', ?)
+      ON CONFLICT(job_id, attempt_number) DO UPDATE SET
+        status = 'running',
+        created_at = excluded.created_at,
+        completed_at = NULL,
+        outcome = NULL,
+        error = NULL,
+        debug_json = NULL
+    `,
+    args: [
+      randomUUID(),
+      input.jobId,
+      input.userId,
+      input.attemptNumber,
+      input.maxAttempts,
+      input.query,
+      input.location,
+      input.maxQuestions,
+      input.startedAt
+    ]
+  });
+}
+async function finishHarvestAttempt(input) {
+  await getDb().execute({
+    sql: `
+      UPDATE harvest_attempts SET
+        status = 'finished',
+        outcome = ?,
+        kernel_session_id = ?,
+        question_count = ?,
+        duration_ms = ?,
+        error = ?,
+        will_retry = ?,
+        kernel_delete_started = ?,
+        kernel_delete_succeeded = ?,
+        kernel_delete_error = ?,
+        browser_close_succeeded = ?,
+        browser_close_error = ?,
+        debug_json = ?,
+        completed_at = ?
+      WHERE job_id = ? AND attempt_number = ?
+    `,
+    args: [
+      input.outcome,
+      input.kernelSessionId,
+      input.questionCount,
+      input.durationMs,
+      input.error,
+      input.willRetry ? 1 : 0,
+      input.kernelDeleteStarted ? 1 : 0,
+      input.kernelDeleteSucceeded == null ? null : input.kernelDeleteSucceeded ? 1 : 0,
+      input.kernelDeleteError,
+      input.browserCloseSucceeded == null ? null : input.browserCloseSucceeded ? 1 : 0,
+      input.browserCloseError,
+      input.debug == null ? null : JSON.stringify(input.debug),
+      input.completedAt,
+      input.jobId,
+      input.attemptNumber
+    ]
+  });
+}
+async function listHarvestAttempts(jobId, userId) {
+  const res = userId == null ? await getDb().execute({
+    sql: `SELECT * FROM harvest_attempts WHERE job_id = ? ORDER BY attempt_number ASC`,
+    args: [jobId]
+  }) : await getDb().execute({
+    sql: `
+          SELECT ha.*
+          FROM harvest_attempts ha
+          INNER JOIN jobs j ON j.id = ha.job_id
+          WHERE ha.job_id = ? AND j.user_id = ?
+          ORDER BY ha.attempt_number ASC
+        `,
+    args: [jobId, userId]
+  });
+  return res.rows.map((r) => rowToHarvestAttemptLog(r));
+}
+async function getJob(id, userId) {
+  const db = getDb();
+  const res = userId ? await db.execute({ sql: "SELECT * FROM jobs WHERE id = ? AND user_id = ?", args: [id, userId] }) : await db.execute({ sql: "SELECT * FROM jobs WHERE id = ?", args: [id] });
+  return res.rows[0] ? deserialize(rowToRawJob(res.rows[0])) : void 0;
+}
+async function listJobs(userId) {
+  const res = await getDb().execute({ sql: "SELECT * FROM jobs WHERE user_id = ? ORDER BY created_at DESC LIMIT 50", args: [userId] });
+  return res.rows.map((r) => deserialize(rowToRawJob(r)));
+}
+async function getPageSnapshot(userId, url) {
+  const res = await getDb().execute({
+    sql: "SELECT content_hash, content, title, content_bytes, truncated, checked_at FROM page_snapshots WHERE user_id = ? AND url = ?",
+    args: [userId, url]
+  });
+  const row = res.rows[0];
+  if (!row) return null;
+  return {
+    contentHash: String(row.content_hash),
+    content: String(row.content),
+    title: row.title == null ? null : String(row.title),
+    contentBytes: Number(row.content_bytes),
+    truncated: Number(row.truncated) === 1,
+    checkedAt: String(row.checked_at)
+  };
+}
+async function upsertPageSnapshot(userId, url, snapshot) {
+  await getDb().execute({
+    sql: `
+      INSERT INTO page_snapshots (user_id, url, content_hash, content, title, content_bytes, truncated, checked_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(user_id, url) DO UPDATE SET
+        content_hash  = excluded.content_hash,
+        content       = excluded.content,
+        title         = excluded.title,
+        content_bytes = excluded.content_bytes,
+        truncated     = excluded.truncated,
+        checked_at    = excluded.checked_at
+    `,
+    args: [userId, url, snapshot.contentHash, snapshot.content, snapshot.title, snapshot.contentBytes, snapshot.truncated ? 1 : 0]
+  });
+}
+var REQUEST_EVENT_RESULT_MAX_BYTES = 32 * 1024;
+function serializeRequestEventResult(result) {
+  if (result == null) return null;
+  const serialized = JSON.stringify(result);
+  const bytes = Buffer.byteLength(serialized, "utf8");
+  if (bytes <= REQUEST_EVENT_RESULT_MAX_BYTES) return serialized;
+  return JSON.stringify({
+    truncated: true,
+    originalBytes: bytes,
+    sha256: createHash("sha256").update(serialized).digest("hex")
+  });
+}
+function rowToRequestEvent(row) {
+  const rawResult = row.result != null ? String(row.result) : null;
+  return {
+    id: String(row.id),
+    user_id: Number(row.user_id),
+    source: String(row.source),
+    status: String(row.status),
+    query: String(row.query),
+    location: row.location != null ? String(row.location) : null,
+    result_count: row.result_count != null ? Number(row.result_count) : null,
+    result: rawResult ? JSON.parse(rawResult) : null,
+    error: row.error != null ? String(row.error) : null,
+    created_at: String(row.created_at)
+  };
+}
+async function logRequestEvent(input) {
+  const id = randomUUID();
+  await getDb().execute({
+    sql: `
+      INSERT INTO request_events (id, user_id, source, status, query, location, result_count, result, error)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      id,
+      input.userId,
+      input.source,
+      input.status,
+      input.query,
+      input.location ?? null,
+      input.resultCount ?? null,
+      serializeRequestEventResult(input.result),
+      input.error ?? null
+    ]
+  });
+  return id;
+}
+async function listRequestEvents(userId, limit = 100) {
+  const res = await getDb().execute({
+    sql: `
+      SELECT id, user_id, source, status, query, location, result_count, NULL AS result, error, created_at
+      FROM request_events
+      WHERE user_id = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `,
+    args: [userId, limit]
+  });
+  return res.rows.map((r) => rowToRequestEvent(r));
+}
+function parseJsonRecordValue(value) {
+  if (value == null) return {};
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function rowToWorkflowSchedule(row) {
+  return {
+    id: String(row.id),
+    user_id: Number(row.user_id),
+    workflow_id: String(row.workflow_id),
+    name: String(row.name),
+    input: parseJsonRecordValue(row.input_json),
+    cadence: String(row.cadence),
+    cron_expr: row.cron_expr != null ? String(row.cron_expr) : null,
+    timezone: String(row.timezone ?? "UTC"),
+    webhook_url: row.webhook_url != null ? String(row.webhook_url) : null,
+    status: String(row.status),
+    next_run_at: row.next_run_at != null ? String(row.next_run_at) : null,
+    last_run_at: row.last_run_at != null ? String(row.last_run_at) : null,
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
+  };
+}
+function rowToWorkflowRun(row) {
+  return {
+    id: String(row.id),
+    user_id: Number(row.user_id),
+    schedule_id: row.schedule_id != null ? String(row.schedule_id) : null,
+    workflow_id: String(row.workflow_id),
+    input: parseJsonRecordValue(row.input_json),
+    status: String(row.status),
+    manifest: row.manifest_json != null ? parseNullableJson(row.manifest_json) : null,
+    error_message: row.error_message != null ? String(row.error_message) : null,
+    queued_at: String(row.queued_at),
+    started_at: row.started_at != null ? String(row.started_at) : null,
+    completed_at: row.completed_at != null ? String(row.completed_at) : null,
+    idempotency_key: row.idempotency_key != null ? String(row.idempotency_key) : null,
+    step_index: row.step_index != null ? Number(row.step_index) : 0,
+    total_steps: row.total_steps != null ? Number(row.total_steps) : null,
+    step_log: parseWorkflowStepLog(row.step_log_json),
+    webhook_url: row.webhook_url != null ? String(row.webhook_url) : null
+  };
+}
+function parseWorkflowStepLog(value) {
+  if (value == null) return [];
+  try {
+    const parsed = JSON.parse(String(value));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function rowToWorkflowArtifact(row) {
+  return {
+    id: String(row.id),
+    run_id: String(row.run_id),
+    user_id: Number(row.user_id),
+    kind: String(row.kind),
+    label: String(row.label),
+    path: String(row.path),
+    content_type: String(row.content_type),
+    bytes: row.bytes != null ? Number(row.bytes) : null,
+    rows_count: row.rows_count != null ? Number(row.rows_count) : null,
+    content: row.content != null ? String(row.content) : null,
+    created_at: String(row.created_at)
+  };
+}
+async function createWorkflowSchedule(input) {
+  const id = randomUUID();
+  await getDb().execute({
+    sql: `
+      INSERT INTO workflow_schedules (
+        id, user_id, workflow_id, name, input_json, cadence, timezone, webhook_url, next_run_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      id,
+      input.userId,
+      input.workflowId,
+      input.name,
+      JSON.stringify(input.workflowInput),
+      input.cadence,
+      input.timezone ?? "UTC",
+      input.webhookUrl ?? null,
+      input.nextRunAt ?? null
+    ]
+  });
+  const schedule = await getWorkflowSchedule(id, input.userId);
+  if (!schedule) throw new Error("Failed to create workflow schedule");
+  return schedule;
+}
+async function getWorkflowSchedule(id, userId) {
+  const res = userId == null ? await getDb().execute({ sql: "SELECT * FROM workflow_schedules WHERE id = ? AND status != ? LIMIT 1", args: [id, "deleted"] }) : await getDb().execute({ sql: "SELECT * FROM workflow_schedules WHERE id = ? AND user_id = ? AND status != ? LIMIT 1", args: [id, userId, "deleted"] });
+  return res.rows[0] ? rowToWorkflowSchedule(res.rows[0]) : null;
+}
+async function listWorkflowSchedules(userId) {
+  const res = await getDb().execute({
+    sql: `SELECT * FROM workflow_schedules WHERE user_id = ? AND status != 'deleted' ORDER BY created_at DESC LIMIT 100`,
+    args: [userId]
+  });
+  return res.rows.map((r) => rowToWorkflowSchedule(r));
+}
+async function patchWorkflowSchedule(input) {
+  const sets = [];
+  const args = [];
+  if (input.name !== void 0) {
+    sets.push("name = ?");
+    args.push(input.name);
+  }
+  if (input.status !== void 0) {
+    sets.push("status = ?");
+    args.push(input.status);
+  }
+  if (input.workflowInput !== void 0) {
+    sets.push("input_json = ?");
+    args.push(JSON.stringify(input.workflowInput));
+  }
+  if (input.cadence !== void 0) {
+    sets.push("cadence = ?");
+    args.push(input.cadence);
+  }
+  if (input.timezone !== void 0) {
+    sets.push("timezone = ?");
+    args.push(input.timezone);
+  }
+  if (input.webhookUrl !== void 0) {
+    sets.push("webhook_url = ?");
+    args.push(input.webhookUrl);
+  }
+  if (input.nextRunAt !== void 0) {
+    sets.push("next_run_at = ?");
+    args.push(input.nextRunAt);
+  }
+  if (sets.length === 0) return getWorkflowSchedule(input.id, input.userId);
+  sets.push(`updated_at = datetime('now')`);
+  await getDb().execute({
+    sql: `UPDATE workflow_schedules SET ${sets.join(", ")} WHERE id = ? AND user_id = ? AND status != 'deleted'`,
+    args: [...args, input.id, input.userId]
+  });
+  return getWorkflowSchedule(input.id, input.userId);
+}
+async function deleteWorkflowSchedule(id, userId) {
+  const res = await getDb().execute({
+    sql: `UPDATE workflow_schedules SET status = 'deleted', updated_at = datetime('now') WHERE id = ? AND user_id = ? AND status != 'deleted'`,
+    args: [id, userId]
+  });
+  return res.rowsAffected > 0;
+}
+async function listDueWorkflowSchedules(nowIso, limit = 10) {
+  const res = await getDb().execute({
+    sql: `
+      SELECT * FROM workflow_schedules
+      WHERE status = 'active' AND next_run_at IS NOT NULL AND next_run_at <= ?
+      ORDER BY next_run_at ASC
+      LIMIT ?
+    `,
+    args: [nowIso, limit]
+  });
+  return res.rows.map((r) => rowToWorkflowSchedule(r));
+}
+async function markWorkflowScheduleRan(id, lastRunAt, nextRunAt) {
+  await getDb().execute({
+    sql: `UPDATE workflow_schedules SET last_run_at = ?, next_run_at = ?, updated_at = datetime('now') WHERE id = ?`,
+    args: [lastRunAt, nextRunAt, id]
+  });
+}
+async function createWorkflowRun(input) {
+  const id = input.id ?? randomUUID();
+  const args = [
+    id,
+    input.userId,
+    input.scheduleId ?? null,
+    input.workflowId,
+    JSON.stringify(input.workflowInput),
+    input.idempotencyKey ?? null,
+    input.webhookUrl ?? null,
+    input.totalSteps ?? null
+  ];
+  try {
+    await getDb().execute({
+      sql: `
+        INSERT INTO workflow_runs (id, user_id, schedule_id, workflow_id, input_json, idempotency_key, webhook_url, total_steps)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      args
+    });
+  } catch (err) {
+    if (input.idempotencyKey) {
+      const existing = await getWorkflowRunByIdempotencyKey(input.idempotencyKey);
+      if (existing) return existing;
+    }
+    throw err;
+  }
+  const run = await getWorkflowRun(id, input.userId);
+  if (!run) throw new Error("Failed to create workflow run");
+  return run;
+}
+async function getWorkflowRun(id, userId) {
+  const res = userId == null ? await getDb().execute({ sql: "SELECT * FROM workflow_runs WHERE id = ? LIMIT 1", args: [id] }) : await getDb().execute({ sql: "SELECT * FROM workflow_runs WHERE id = ? AND user_id = ? LIMIT 1", args: [id, userId] });
+  return res.rows[0] ? rowToWorkflowRun(res.rows[0]) : null;
+}
+async function getWorkflowRunByIdempotencyKey(idempotencyKey) {
+  const res = await getDb().execute({ sql: "SELECT * FROM workflow_runs WHERE idempotency_key = ? LIMIT 1", args: [idempotencyKey] });
+  return res.rows[0] ? rowToWorkflowRun(res.rows[0]) : null;
+}
+async function listWorkflowRuns(userId, limit = 50) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM workflow_runs WHERE user_id = ? ORDER BY queued_at DESC LIMIT ?",
+    args: [userId, limit]
+  });
+  return res.rows.map((r) => rowToWorkflowRun(r));
+}
+async function markWorkflowRunRunning(id) {
+  await getDb().execute({
+    sql: `UPDATE workflow_runs SET status = 'running', started_at = COALESCE(started_at, datetime('now')) WHERE id = ?`,
+    args: [id]
+  });
+}
+async function completeWorkflowRunRecord(id, status, manifest) {
+  await getDb().execute({
+    sql: `UPDATE workflow_runs SET status = ?, manifest_json = ?, completed_at = datetime('now') WHERE id = ?`,
+    args: [status, JSON.stringify(manifest), id]
+  });
+}
+async function failWorkflowRunRecord(id, errorMessage, manifest) {
+  await getDb().execute({
+    sql: `UPDATE workflow_runs SET status = 'failed', error_message = ?, manifest_json = ?, completed_at = datetime('now') WHERE id = ?`,
+    args: [errorMessage, manifest == null ? null : JSON.stringify(manifest), id]
+  });
+}
+function workflowArtifactContentType(kind) {
+  if (kind === "html_report") return "text/html; charset=utf-8";
+  if (kind === "csv") return "text/csv; charset=utf-8";
+  if (kind === "json") return "application/json; charset=utf-8";
+  return "text/plain; charset=utf-8";
+}
+async function insertWorkflowArtifact(runId, userId, artifact) {
+  await getDb().execute({
+    sql: `
+      INSERT INTO workflow_artifacts (id, run_id, user_id, kind, label, path, content_type, bytes, rows_count, content)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      randomUUID(),
+      runId,
+      userId,
+      artifact.kind,
+      artifact.label,
+      artifact.path,
+      workflowArtifactContentType(artifact.kind),
+      artifact.bytes ?? null,
+      artifact.rows ?? null,
+      artifact.content ?? null
+    ]
+  });
+}
+async function replaceWorkflowArtifacts(runId, userId, artifacts) {
+  await getDb().execute({ sql: "DELETE FROM workflow_artifacts WHERE run_id = ? AND user_id = ?", args: [runId, userId] });
+  for (const artifact of artifacts) await insertWorkflowArtifact(runId, userId, artifact);
+  return listWorkflowArtifacts(runId, userId);
+}
+async function appendWorkflowArtifacts(runId, userId, artifacts) {
+  for (const artifact of artifacts) await insertWorkflowArtifact(runId, userId, artifact);
+  return listWorkflowArtifacts(runId, userId);
+}
+async function getWorkflowRunStepState(id, userId) {
+  const res = userId == null ? await getDb().execute({ sql: "SELECT step_index, total_steps, step_state_json, step_log_json FROM workflow_runs WHERE id = ? LIMIT 1", args: [id] }) : await getDb().execute({ sql: "SELECT step_index, total_steps, step_state_json, step_log_json FROM workflow_runs WHERE id = ? AND user_id = ? LIMIT 1", args: [id, userId] });
+  const row = res.rows[0];
+  if (!row) return null;
+  return {
+    stepIndex: row.step_index != null ? Number(row.step_index) : 0,
+    totalSteps: row.total_steps != null ? Number(row.total_steps) : null,
+    state: row.step_state_json != null ? parseNullableJson(row.step_state_json) : null,
+    stepLog: parseWorkflowStepLog(row.step_log_json)
+  };
+}
+async function advanceWorkflowRunStep(id, input) {
+  const stepLog = [...input.appendLog, input.logEntry];
+  await getDb().execute({
+    sql: `UPDATE workflow_runs SET status = ?, step_index = ?, total_steps = ?, step_state_json = ?, step_log_json = ?, started_at = COALESCE(started_at, datetime('now')) WHERE id = ?`,
+    args: [input.status, input.stepIndex, input.totalSteps, JSON.stringify(input.state ?? null), JSON.stringify(stepLog), id]
+  });
+}
+async function listWorkflowArtifacts(runId, userId) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM workflow_artifacts WHERE run_id = ? AND user_id = ? ORDER BY created_at ASC",
+    args: [runId, userId]
+  });
+  return res.rows.map((r) => rowToWorkflowArtifact(r));
+}
+async function getWorkflowArtifact(id, userId) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM workflow_artifacts WHERE id = ? AND user_id = ? LIMIT 1",
+    args: [id, userId]
+  });
+  return res.rows[0] ? rowToWorkflowArtifact(res.rows[0]) : null;
+}
+async function recordWorkflowWebhookDelivery(input) {
+  await getDb().execute({
+    sql: `
+      INSERT INTO workflow_webhook_deliveries (
+        id, run_id, schedule_id, user_id, webhook_url, status, attempts, last_error, delivered_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      randomUUID(),
+      input.runId,
+      input.scheduleId ?? null,
+      input.userId,
+      input.webhookUrl,
+      input.status,
+      input.attempts,
+      input.lastError ?? null,
+      input.status === "delivered" ? (/* @__PURE__ */ new Date()).toISOString() : null
+    ]
+  });
+}
+async function countActiveUsers() {
+  const res = await getDb().execute(`SELECT COUNT(*) as n FROM users WHERE active = 1`);
+  return Number(res.rows[0]?.n ?? 0);
+}
+async function countActiveJobsForUser(userId) {
+  const res = await getDb().execute({
+    sql: `SELECT COUNT(*) as n FROM jobs WHERE user_id = ? AND (status = 'pending' OR (status = 'running' AND started_at > datetime('now', '-10 minutes')))`,
+    args: [userId]
+  });
+  return Number(res.rows[0]?.n ?? 0);
+}
+async function claimPendingJob() {
+  const db = getDb();
+  const res = await db.execute(`SELECT * FROM jobs WHERE status = 'pending' ORDER BY created_at LIMIT 1`);
+  const job = res.rows[0] ? rowToRawJob(res.rows[0]) : void 0;
+  if (!job) return void 0;
+  const upd = await db.execute({
+    sql: `UPDATE jobs SET status = 'running', started_at = datetime('now') WHERE id = ? AND status = 'pending'`,
+    args: [job.id]
+  });
+  return upd.rowsAffected === 0 ? void 0 : { ...job, status: "running" };
+}
+async function completeJob(id, result) {
+  await getDb().execute({ sql: `UPDATE jobs SET status = 'done', result = ?, completed_at = datetime('now') WHERE id = ?`, args: [JSON.stringify(result), id] });
+}
+async function failJob(id, error) {
+  await getDb().execute({ sql: `UPDATE jobs SET status = 'failed', error = ?, completed_at = datetime('now') WHERE id = ?`, args: [error, id] });
+}
+async function cancelJob(id, reason) {
+  await getDb().execute({ sql: `UPDATE jobs SET status = 'cancelled', error = ?, completed_at = datetime('now') WHERE id = ?`, args: [reason, id] });
+}
+function rowToKpoJob(row) {
+  return {
+    id: String(row.id),
+    user_id: Number(row.user_id),
+    status: String(row.status),
+    entity_name: String(row.entity_name),
+    entity_type: String(row.entity_type),
+    url: row.url != null ? String(row.url) : null,
+    request: String(row.request),
+    result: row.result != null ? String(row.result) : null,
+    error: row.error != null ? String(row.error) : null,
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
+  };
+}
+function rowToKpoPhaseLog(row) {
+  return {
+    id: Number(row.id),
+    job_id: String(row.job_id),
+    phase: String(row.phase),
+    output: String(row.output),
+    created_at: String(row.created_at)
+  };
+}
+async function createKpoJob(jobId, userId, entityName, entityType, request, url) {
+  await getDb().execute({
+    sql: `INSERT INTO kpo_jobs (id, user_id, status, entity_name, entity_type, url, request) VALUES (?, ?, 'pending', ?, ?, ?, ?)`,
+    args: [jobId, userId, entityName, entityType, url ?? null, JSON.stringify(request)]
+  });
+}
+async function claimPendingKpoJob() {
+  const db = getDb();
+  const upd = await db.execute(
+    `UPDATE kpo_jobs SET status='running', updated_at=datetime('now') WHERE id = (SELECT id FROM kpo_jobs WHERE status='pending' ORDER BY created_at ASC LIMIT 1) RETURNING *`
+  );
+  if (upd.rowsAffected === 0) return null;
+  return upd.rows[0] ? rowToKpoJob(upd.rows[0]) : null;
+}
+async function getKpoJob(jobId) {
+  const res = await getDb().execute({ sql: `SELECT * FROM kpo_jobs WHERE id = ?`, args: [jobId] });
+  return res.rows[0] ? rowToKpoJob(res.rows[0]) : null;
+}
+async function updateKpoJobState(jobId, status) {
+  await getDb().execute({ sql: `UPDATE kpo_jobs SET status = ?, updated_at = datetime('now') WHERE id = ?`, args: [status, jobId] });
+}
+async function completeKpoJob(jobId, result) {
+  await getDb().execute({ sql: `UPDATE kpo_jobs SET status = 'done', result = ?, updated_at = datetime('now') WHERE id = ?`, args: [JSON.stringify(result), jobId] });
+}
+async function failKpoJob(jobId, error) {
+  await getDb().execute({ sql: `UPDATE kpo_jobs SET status = 'failed', error = ?, updated_at = datetime('now') WHERE id = ?`, args: [error, jobId] });
+}
+async function logKpoPhaseComplete(jobId, phase, output) {
+  await getDb().execute({
+    sql: `INSERT INTO kpo_phase_log (job_id, phase, output) VALUES (?, ?, ?)`,
+    args: [jobId, phase, JSON.stringify(output)]
+  });
+}
+async function getKpoPhaseLog(jobId) {
+  const res = await getDb().execute({ sql: `SELECT * FROM kpo_phase_log WHERE job_id = ? ORDER BY created_at ASC`, args: [jobId] });
+  return res.rows.map((r) => rowToKpoPhaseLog(r));
+}
+async function listKpoJobs(userId) {
+  const res = userId != null ? await getDb().execute({ sql: `SELECT * FROM kpo_jobs WHERE user_id = ? ORDER BY created_at DESC LIMIT 50`, args: [userId] }) : await getDb().execute(`SELECT * FROM kpo_jobs ORDER BY created_at DESC LIMIT 50`);
+  return res.rows.map((r) => rowToKpoJob(r));
+}
+async function getUserByStripeCustomerId(customerId) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM users WHERE stripe_customer_id = ? AND active = 1",
+    args: [customerId]
+  });
+  return res.rows[0] ? rowToUser(res.rows[0]) : void 0;
+}
+async function setStripeCustomerId(userId, customerId) {
+  await getDb().execute({
+    sql: "UPDATE users SET stripe_customer_id = ? WHERE id = ?",
+    args: [customerId, userId]
+  });
+}
+async function setExtraConcurrencySlots(userId, slots) {
+  await getDb().execute({
+    sql: "UPDATE users SET extra_concurrency_slots = ? WHERE id = ?",
+    args: [Math.max(0, slots), userId]
+  });
+}
+async function setConcurrencySubId(userId, subId) {
+  await getDb().execute({
+    sql: "UPDATE users SET concurrency_stripe_sub_id = ? WHERE id = ?",
+    args: [subId, userId]
+  });
+}
+async function setSubscriptionTier(userId, tier, concurrency, subId) {
+  await getDb().execute({
+    sql: "UPDATE users SET subscription_tier = ?, subscription_concurrency = ?, subscription_id = ? WHERE id = ?",
+    args: [tier, Math.max(0, Math.round(concurrency)), subId, userId]
+  });
+}
+function rowToConnectedAccountBillingState(row) {
+  return {
+    user_id: Number(row.user_id),
+    stripe_subscription_id: row.stripe_subscription_id != null ? String(row.stripe_subscription_id) : null,
+    stripe_subscription_item_id: row.stripe_subscription_item_id != null ? String(row.stripe_subscription_item_id) : null,
+    price_id: row.price_id != null ? String(row.price_id) : null,
+    quantity: Math.max(0, Number(row.quantity ?? 0)),
+    status: ["pending", "synced", "blocked", "error"].includes(String(row.status)) ? String(row.status) : "error",
+    last_error_code: row.last_error_code != null ? String(row.last_error_code) : null,
+    checked_at: String(row.checked_at),
+    synced_at: row.synced_at != null ? String(row.synced_at) : null,
+    updated_at: String(row.updated_at)
+  };
+}
+async function getConnectedAccountBillingState(userId) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM connected_account_billing WHERE user_id = ? LIMIT 1",
+    args: [userId]
+  });
+  const row = res.rows[0];
+  return row ? rowToConnectedAccountBillingState(row) : null;
+}
+async function setConnectedAccountBillingState(input) {
+  const quantity = Math.max(0, Math.round(input.quantity));
+  await getDb().execute({
+    sql: `INSERT INTO connected_account_billing
+      (user_id, stripe_subscription_id, stripe_subscription_item_id, price_id, quantity, status, last_error_code, checked_at, synced_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), CASE WHEN ? THEN datetime('now') ELSE NULL END, datetime('now'))
+      ON CONFLICT(user_id) DO UPDATE SET
+        stripe_subscription_id = excluded.stripe_subscription_id,
+        stripe_subscription_item_id = excluded.stripe_subscription_item_id,
+        price_id = excluded.price_id,
+        quantity = excluded.quantity,
+        status = excluded.status,
+        last_error_code = excluded.last_error_code,
+        checked_at = datetime('now'),
+        synced_at = CASE WHEN ? THEN datetime('now') ELSE connected_account_billing.synced_at END,
+        updated_at = datetime('now')`,
+    args: [
+      input.userId,
+      input.stripeSubscriptionId,
+      input.stripeSubscriptionItemId,
+      input.priceId,
+      quantity,
+      input.status,
+      input.lastErrorCode ?? null,
+      input.synced === true ? 1 : 0,
+      input.synced === true ? 1 : 0
+    ]
+  });
+  const state = await getConnectedAccountBillingState(input.userId);
+  if (!state) throw new Error("connected account billing state was not persisted");
+  return state;
+}
+async function listUsersDueForConnectedAccountBillingReconciliation(staleMinutes = 60, limit = 20) {
+  const modifier = `-${Math.max(1, Math.round(staleMinutes))} minutes`;
+  const res = await getDb().execute({
+    sql: `SELECT u.*
+      FROM users u
+      LEFT JOIN connected_account_billing b ON b.user_id = u.id
+      WHERE u.active = 1
+        AND u.subscription_id IS NOT NULL
+        AND (b.checked_at IS NULL OR b.checked_at <= datetime('now', ?))
+      ORDER BY COALESCE(b.checked_at, u.created_at) ASC
+      LIMIT ?`,
+    args: [modifier, Math.max(1, Math.min(100, Math.round(limit)))]
+  });
+  return res.rows.map((row) => rowToUser(row));
+}
+async function setMemoryPlan(userId, plan, subscriptionId) {
+  await getDb().execute({
+    sql: "UPDATE users SET memory_plan = ?, memory_subscription_id = ? WHERE id = ?",
+    args: [plan, subscriptionId, userId]
+  });
+}
+async function getMemoryPlan(userId) {
+  const res = await getDb().execute({ sql: "SELECT memory_plan, memory_subscription_id FROM users WHERE id = ?", args: [userId] });
+  const row = res.rows[0];
+  return {
+    plan: row?.memory_plan != null ? String(row.memory_plan) : "free",
+    memory_subscription_id: row?.memory_subscription_id != null ? String(row.memory_subscription_id) : null
+  };
+}
+async function getMemoryProvisioned(userId) {
+  const res = await getDb().execute({ sql: "SELECT memory_provisioned FROM users WHERE id = ?", args: [userId] });
+  const row = res.rows[0];
+  return Number(row?.memory_provisioned ?? 0) === 1;
+}
+async function setMemoryProvisioned(userId, provisioned) {
+  await getDb().execute({ sql: "UPDATE users SET memory_provisioned = ? WHERE id = ?", args: [provisioned ? 1 : 0, userId] });
+}
+async function resolveUserByMemorySubscription(subscriptionId) {
+  const res = await getDb().execute({ sql: "SELECT * FROM users WHERE memory_subscription_id = ? AND active = 1", args: [subscriptionId] });
+  return res.rows[0] ? rowToUser(res.rows[0]) : void 0;
+}
+var CREDIT_LOT_TTL = "+3 months";
+async function ensureMigrated(userId) {
+  const db = getDb();
+  const inserted = await db.execute({
+    sql: `INSERT INTO credit_lots (user_id, amount_mc, remaining_mc, source, expires_at)
+          SELECT ?, legacy.balance_mc, legacy.balance_mc, 'migration', datetime('now', ?)
+          FROM (
+            SELECT COALESCE(SUM(amount_mc), 0) AS balance_mc
+            FROM ledger
+            WHERE user_id = ?
+          ) AS legacy
+          WHERE legacy.balance_mc > 0
+            AND EXISTS (
+              SELECT 1 FROM ledger
+              WHERE user_id = ? AND created_at < ?
+            )
+            AND NOT EXISTS (
+              SELECT 1 FROM credit_lots WHERE user_id = ?
+            )`,
+    args: [userId, CREDIT_LOT_TTL, userId, userId, CREDIT_LOTS_EPOCH, userId]
+  });
+  return inserted.rowsAffected;
+}
+async function expireOldLots() {
+  const db = getDb();
+  const lots = await db.execute({
+    sql: `SELECT id
+          FROM credit_lots
+          WHERE remaining_mc > 0
+            AND never_expires = 0
+            AND expires_at <= datetime('now')
+          LIMIT 500`
+  });
+  if (lots.rows.length === 0) return { expired_lots: 0, expired_mc: 0 };
+  const claims = [];
+  const stmts = [];
+  for (const lot of lots.rows) {
+    const lotId = Number(lot.id);
+    const token = randomUUID();
+    claims.push({ token, insertResultIndex: stmts.length });
+    stmts.push({
+      sql: `INSERT OR IGNORE INTO credit_lot_expirations (lot_id, user_id, amount_mc, claim_token)
+            SELECT id, user_id, remaining_mc, ?
+            FROM credit_lots
+            WHERE id = ?
+              AND remaining_mc > 0
+              AND never_expires = 0
+              AND expires_at <= datetime('now')`,
+      args: [token, lotId]
+    });
+    stmts.push({
+      sql: `UPDATE credit_lots
+            SET remaining_mc = 0
+            WHERE id = ?
+              AND EXISTS (
+                SELECT 1 FROM credit_lot_expirations
+                WHERE lot_id = ? AND claim_token = ?
+              )`,
+      args: [lotId, lotId, token]
+    });
+    stmts.push({
+      sql: `INSERT INTO ledger (user_id, amount_mc, operation, description)
+            SELECT user_id, -amount_mc, 'credit_expired', 'credits expired'
+            FROM credit_lot_expirations
+            WHERE lot_id = ? AND claim_token = ?`,
+      args: [lotId, token]
+    });
+  }
+  const results = await db.batch(stmts, "write");
+  const claimedTokens = claims.filter((claim) => results[claim.insertResultIndex]?.rowsAffected === 1).map((claim) => claim.token);
+  if (claimedTokens.length === 0) return { expired_lots: 0, expired_mc: 0 };
+  const placeholders = claimedTokens.map(() => "?").join(", ");
+  const expired = await db.execute({
+    sql: `SELECT user_id, amount_mc
+          FROM credit_lot_expirations
+          WHERE claim_token IN (${placeholders})`,
+    args: claimedTokens
+  });
+  const users = new Set(expired.rows.map((row) => Number(row.user_id)));
+  for (const uid of users) await reconcileBalanceMc(uid);
+  return {
+    expired_lots: expired.rows.length,
+    expired_mc: expired.rows.reduce((sum, row) => sum + Number(row.amount_mc), 0)
+  };
+}
+async function migrateExistingBalancesToLots() {
+  const db = getDb();
+  const res = await db.execute({
+    sql: `SELECT DISTINCT u.id AS user_id
+          FROM users u
+          JOIN ledger l ON l.user_id = u.id
+          WHERE l.created_at < ?
+            AND NOT EXISTS (SELECT 1 FROM credit_lots WHERE user_id = u.id)`,
+    args: [CREDIT_LOTS_EPOCH]
+  });
+  let migrated = 0;
+  let totalMc = 0;
+  for (const row of res.rows) {
+    const uid = Number(row.user_id);
+    const inserted = await ensureMigrated(uid);
+    if (inserted === 0) continue;
+    const lot = await db.execute({
+      sql: `SELECT amount_mc FROM credit_lots
+            WHERE user_id = ? AND source = 'migration'
+            ORDER BY id DESC LIMIT 1`,
+      args: [uid]
+    });
+    const amountMc = Number(lot.rows[0]?.amount_mc ?? 0);
+    await reconcileBalanceMc(uid);
+    migrated += 1;
+    totalMc += amountMc;
+  }
+  return { migrated, total_mc: totalMc };
+}
+async function creditMc(userId, mc, operation, description, stripePaymentIntent, options) {
+  const db = getDb();
+  await ensureMigrated(userId);
+  let neverExpires = options?.neverExpires;
+  if (neverExpires === void 0 && mc > 0) {
+    const tier = await db.execute({ sql: "SELECT subscription_tier FROM users WHERE id = ? LIMIT 1", args: [userId] });
+    neverExpires = String(tier.rows[0]?.subscription_tier ?? "").startsWith("sonic");
+  }
+  const expiry = neverExpires ? "9999-12-31 23:59:59" : null;
+  if (stripePaymentIntent) {
+    const stmts2 = [{
+      sql: "INSERT OR IGNORE INTO ledger (user_id, amount_mc, operation, description, stripe_pi) VALUES (?, ?, ?, ?, ?)",
+      args: [userId, mc, operation, description ?? null, stripePaymentIntent]
+    }];
+    if (mc > 0) {
+      stmts2.push({
+        sql: `INSERT INTO credit_lots (user_id, amount_mc, remaining_mc, source, stripe_pi, expires_at, never_expires)
+              SELECT ?, ?, ?, ?, ?, COALESCE(?, datetime('now', ?)), ?
+              WHERE changes() = 1`,
+        args: [userId, mc, mc, operation, stripePaymentIntent, expiry, CREDIT_LOT_TTL, neverExpires ? 1 : 0]
+      });
+    }
+    stmts2.push({
+      sql: "UPDATE users SET balance_mc = balance_mc + ? WHERE id = ? AND changes() = 1",
+      args: [mc, userId]
+    });
+    await db.batch(stmts2, "write");
+    const res2 = await db.execute({ sql: "SELECT balance_mc FROM users WHERE id = ?", args: [userId] });
+    return Number(res2.rows[0]?.balance_mc ?? 0);
+  }
+  const stmts = [];
+  if (mc > 0) {
+    stmts.push({ sql: `INSERT INTO credit_lots (user_id, amount_mc, remaining_mc, source, stripe_pi, expires_at, never_expires) VALUES (?, ?, ?, ?, ?, COALESCE(?, datetime('now', ?)), ?)`, args: [userId, mc, mc, operation, null, expiry, CREDIT_LOT_TTL, neverExpires ? 1 : 0] });
+  }
+  stmts.push({ sql: "UPDATE users SET balance_mc = balance_mc + ? WHERE id = ?", args: [mc, userId] });
+  stmts.push({ sql: "INSERT INTO ledger (user_id, amount_mc, operation, description, stripe_pi) VALUES (?, ?, ?, ?, ?)", args: [userId, mc, operation, description ?? null, null] });
+  await db.batch(stmts, "write");
+  const res = await db.execute({ sql: "SELECT balance_mc FROM users WHERE id = ?", args: [userId] });
+  return Number(res.rows[0]?.balance_mc ?? 0);
+}
+async function creditMcIdempotent(userId, mc, operation, description, idempotencyKey, options) {
+  if (!Number.isSafeInteger(mc) || mc <= 0) throw new Error("idempotent credit amount must be a positive integer");
+  if (!idempotencyKey || idempotencyKey.length > 500) throw new Error("idempotent credit key is required and must be bounded");
+  const db = getDb();
+  await ensureMigrated(userId);
+  let neverExpires = options?.neverExpires;
+  if (neverExpires === void 0) {
+    const tier = await db.execute({ sql: "SELECT subscription_tier FROM users WHERE id = ? LIMIT 1", args: [userId] });
+    neverExpires = String(tier.rows[0]?.subscription_tier ?? "").startsWith("sonic");
+  }
+  const expiry = neverExpires ? "9999-12-31 23:59:59" : null;
+  const readBalance = async () => {
+    const res = await db.execute({ sql: "SELECT balance_mc FROM users WHERE id = ?", args: [userId] });
+    return Number(res.rows[0]?.balance_mc ?? 0);
+  };
+  let results;
+  try {
+    results = await db.batch([
+      {
+        sql: "INSERT OR IGNORE INTO billing_credits (idempotency_key, user_id, amount_mc, operation, description, status) VALUES (?, ?, ?, ?, ?, 'claimed')",
+        args: [idempotencyKey, userId, mc, operation, description]
+      },
+      {
+        sql: "UPDATE billing_credits SET status = 'applying' WHERE idempotency_key = ? AND user_id = ? AND amount_mc = ? AND operation = ? AND description = ? AND status = 'claimed'",
+        args: [idempotencyKey, userId, mc, operation, description]
+      },
+      {
+        sql: `INSERT INTO credit_lots (user_id, amount_mc, remaining_mc, source, stripe_pi, expires_at, never_expires)
+              SELECT user_id, amount_mc, amount_mc, operation, NULL, COALESCE(?, datetime('now', ?)), ?
+              FROM billing_credits
+              WHERE idempotency_key = ? AND status = 'applying'`,
+        args: [expiry, CREDIT_LOT_TTL, neverExpires ? 1 : 0, idempotencyKey]
+      },
+      {
+        sql: `UPDATE users
+              SET balance_mc = balance_mc + COALESCE((
+                SELECT amount_mc FROM billing_credits WHERE idempotency_key = ? AND status = 'applying'
+              ), 0)
+              WHERE id = ?`,
+        args: [idempotencyKey, userId]
+      },
+      {
+        sql: "INSERT INTO ledger (user_id, amount_mc, operation, description) SELECT user_id, amount_mc, operation, description FROM billing_credits WHERE idempotency_key = ? AND status = 'applying'",
+        args: [idempotencyKey]
+      },
+      {
+        sql: "UPDATE billing_credits SET status = 'applied', applied_at = datetime('now') WHERE idempotency_key = ? AND status = 'applying'",
+        args: [idempotencyKey]
+      }
+    ], "write");
+  } catch (error) {
+    try {
+      const recovered = await db.execute({
+        sql: "SELECT user_id, amount_mc, operation, description FROM billing_credits WHERE idempotency_key = ? AND status = 'applied' LIMIT 1",
+        args: [idempotencyKey]
+      });
+      const row2 = recovered.rows[0];
+      if (row2 && Number(row2.user_id) === userId && Number(row2.amount_mc) === mc && String(row2.operation) === operation && String(row2.description) === description) {
+        return { ok: true, balance_mc: await readBalance(), duplicate: true };
+      }
+    } catch {
+    }
+    throw error;
+  }
+  const claim = await db.execute({
+    sql: "SELECT user_id, amount_mc, operation, description, status FROM billing_credits WHERE idempotency_key = ? LIMIT 1",
+    args: [idempotencyKey]
+  });
+  const row = claim.rows[0];
+  if (!row || Number(row.user_id) !== userId || Number(row.amount_mc) !== mc || String(row.operation) !== operation || String(row.description) !== description) {
+    throw new Error("idempotent credit key conflicts with another credit");
+  }
+  return {
+    ok: String(row.status) === "applied",
+    balance_mc: await readBalance(),
+    duplicate: results[1]?.rowsAffected === 0 && String(row.status) === "applied"
+  };
+}
+async function ledgerExistsForOperation(userId, operation) {
+  const res = await getDb().execute({
+    sql: "SELECT 1 FROM ledger WHERE user_id = ? AND operation = ? LIMIT 1",
+    args: [userId, operation]
+  });
+  return res.rows.length > 0;
+}
+async function claimMonthlyFreeRefresh(userId, month) {
+  const res = await getDb().execute({
+    sql: "INSERT OR IGNORE INTO free_credit_refreshes (user_id, month) VALUES (?, ?)",
+    args: [userId, month]
+  });
+  return res.rowsAffected > 0;
+}
+async function debitMc(userId, mc, operation, description) {
+  const debit = await debitMcIdempotent(
+    userId,
+    mc,
+    operation,
+    description ?? "",
+    `debit:${randomUUID()}`
+  );
+  return { ok: debit.ok, balance_mc: debit.balance_mc };
+}
+async function debitMcIdempotent(userId, mc, operation, description, idempotencyKey) {
+  if (!Number.isSafeInteger(mc) || mc <= 0) throw new Error("idempotent debit amount must be a positive integer");
+  if (!idempotencyKey || idempotencyKey.length > 500) throw new Error("idempotent debit key is required and must be bounded");
+  const db = getDb();
+  await ensureMigrated(userId);
+  let results;
+  try {
+    results = await db.batch([
+      {
+        // An unfunded claim may be retried with a corrected estimate under the
+        // same logical operation fingerprint. Applied claims remain immutable.
+        sql: "UPDATE billing_debits SET amount_mc = ? WHERE idempotency_key = ? AND user_id = ? AND operation = ? AND description = ? AND status = 'claimed'",
+        args: [mc, idempotencyKey, userId, operation, description]
+      },
+      {
+        sql: "INSERT OR IGNORE INTO billing_debits (idempotency_key, user_id, amount_mc, operation, description, status) VALUES (?, ?, ?, ?, ?, 'claimed')",
+        args: [idempotencyKey, userId, mc, operation, description]
+      },
+      {
+        sql: `UPDATE users
+              SET balance_mc = balance_mc - ?
+              WHERE id = ?
+                AND balance_mc >= ?
+                AND (SELECT COALESCE(SUM(remaining_mc), 0)
+                     FROM credit_lots
+                     WHERE user_id = ?
+                       AND remaining_mc > 0
+                       AND (never_expires = 1 OR expires_at > datetime('now'))) >= ?
+                AND EXISTS (SELECT 1 FROM billing_debits WHERE idempotency_key = ? AND user_id = ? AND amount_mc = ? AND operation = ? AND description = ? AND status = 'claimed')`,
+        args: [mc, userId, mc, userId, mc, idempotencyKey, userId, mc, operation, description]
+      },
+      {
+        sql: "UPDATE billing_debits SET status = 'applying' WHERE idempotency_key = ? AND user_id = ? AND amount_mc = ? AND operation = ? AND description = ? AND status = 'claimed' AND changes() = 1",
+        args: [idempotencyKey, userId, mc, operation, description]
+      },
+      {
+        sql: `INSERT OR IGNORE INTO billing_debit_allocations
+                (debit_idempotency_key, lot_id, user_id, amount_mc, expires_at)
+              WITH ordered AS MATERIALIZED (
+                SELECT id,
+                       remaining_mc,
+                       expires_at,
+                       COALESCE(SUM(remaining_mc) OVER (
+                         ORDER BY never_expires ASC, expires_at ASC, granted_at ASC, id ASC
+                         ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+                       ), 0) AS prior_mc
+                FROM credit_lots
+                WHERE user_id = ? AND remaining_mc > 0 AND (never_expires = 1 OR expires_at > datetime('now'))
+              ), allocation AS (
+                SELECT id, expires_at, MIN(remaining_mc, MAX(0, ? - prior_mc)) AS take_mc
+                FROM ordered
+              )
+              SELECT ?, id, ?, take_mc, expires_at
+              FROM allocation
+              WHERE take_mc > 0
+                AND EXISTS (SELECT 1 FROM billing_debits WHERE idempotency_key = ? AND status = 'applying')`,
+        args: [userId, mc, idempotencyKey, userId, idempotencyKey]
+      },
+      {
+        sql: `UPDATE credit_lots
+              SET remaining_mc = remaining_mc - COALESCE((
+                SELECT amount_mc FROM billing_debit_allocations
+                WHERE debit_idempotency_key = ? AND lot_id = credit_lots.id
+              ), 0)
+              WHERE id IN (
+                SELECT lot_id FROM billing_debit_allocations WHERE debit_idempotency_key = ?
+              )
+                AND EXISTS (SELECT 1 FROM billing_debits WHERE idempotency_key = ? AND status = 'applying')`,
+        args: [idempotencyKey, idempotencyKey, idempotencyKey]
+      },
+      {
+        sql: "INSERT INTO ledger (user_id, amount_mc, operation, description) SELECT user_id, -amount_mc, operation, description FROM billing_debits WHERE idempotency_key = ? AND status = 'applying'",
+        args: [idempotencyKey]
+      },
+      {
+        sql: "UPDATE billing_debits SET status = 'applied', applied_at = datetime('now') WHERE idempotency_key = ? AND status = 'applying'",
+        args: [idempotencyKey]
+      }
+    ], "write");
+  } catch (error) {
+    try {
+      const recovered = await db.execute({
+        sql: "SELECT user_id, amount_mc, operation, description, status FROM billing_debits WHERE idempotency_key = ? AND status = 'applied' LIMIT 1",
+        args: [idempotencyKey]
+      });
+      const row2 = recovered.rows[0];
+      if (row2 && Number(row2.user_id) === userId && Number(row2.amount_mc) === mc && String(row2.operation) === operation && String(row2.description) === description) {
+        const balance2 = await db.execute({ sql: "SELECT balance_mc FROM users WHERE id = ?", args: [userId] });
+        return { ok: true, balance_mc: Number(balance2.rows[0]?.balance_mc ?? 0), duplicate: true };
+      }
+    } catch {
+    }
+    throw error;
+  }
+  const claim = await db.execute({
+    sql: "SELECT user_id, amount_mc, operation, description, status FROM billing_debits WHERE idempotency_key = ? LIMIT 1",
+    args: [idempotencyKey]
+  });
+  const row = claim.rows[0];
+  if (!row || Number(row.user_id) !== userId || Number(row.amount_mc) !== mc || String(row.operation) !== operation || String(row.description) !== description) {
+    throw new Error("idempotent debit key conflicts with another debit");
+  }
+  const balance = await db.execute({ sql: "SELECT balance_mc FROM users WHERE id = ?", args: [userId] });
+  return {
+    ok: String(row.status) === "applied",
+    balance_mc: Number(balance.rows[0]?.balance_mc ?? 0),
+    duplicate: results[2]?.rowsAffected === 0 && String(row.status) === "applied"
+  };
+}
+async function settleDebitMcIdempotent(userId, debitIdempotencyKey, finalAmountMc, refundOperation, description, sourceSurface) {
+  if (!Number.isSafeInteger(finalAmountMc) || finalAmountMc < 0) {
+    throw new Error("idempotent debit settlement amount must be a non-negative integer");
+  }
+  if (!debitIdempotencyKey || debitIdempotencyKey.length > 500) {
+    throw new Error("idempotent debit settlement key is required and must be bounded");
+  }
+  if (!refundOperation || !sourceSurface) {
+    throw new Error("idempotent debit settlement operation and source are required");
+  }
+  const db = getDb();
+  await ensureMigrated(userId);
+  const settlementKey = `debit-settlement:${createHash("sha256").update(debitIdempotencyKey).digest("hex")}`;
+  const billingClass = "wallet_hold_settlement";
+  const eventId = randomUUID();
+  const metadata = JSON.stringify({ debitIdempotencyKey, refundOperation, description });
+  const readReceipt = async () => {
+    const receipt2 = await db.execute({
+      sql: `SELECT e.user_id,
+                   e.status,
+                   e.amount_mc AS final_amount_mc,
+                   e.billing_class,
+                   e.source_surface,
+                   e.settled_at,
+                   d.amount_mc AS held_amount_mc
+            FROM billing_events e
+            JOIN billing_debits d ON d.idempotency_key = ?
+            WHERE e.idempotency_key = ?
+              AND d.user_id = e.user_id
+              AND d.status = 'applied'
+            LIMIT 1`,
+      args: [debitIdempotencyKey, settlementKey]
+    });
+    const row = receipt2.rows[0];
+    if (!row) return null;
+    if (Number(row.user_id) !== userId || String(row.billing_class) !== billingClass || String(row.source_surface) !== sourceSurface) {
+      throw new Error("idempotent debit settlement key conflicts with another settlement");
+    }
+    if (String(row.status) !== "settled") return null;
+    const heldAmountMc = Number(row.held_amount_mc);
+    const durableFinalAmountMc = Number(row.final_amount_mc);
+    if (!Number.isSafeInteger(heldAmountMc) || !Number.isSafeInteger(durableFinalAmountMc) || durableFinalAmountMc < 0 || durableFinalAmountMc > heldAmountMc) {
+      throw new Error("idempotent debit settlement receipt is invalid");
+    }
+    const nominalRefundMc = heldAmountMc - durableFinalAmountMc;
+    const allocationRefund = await db.execute({
+      sql: `WITH ordered AS (
+              SELECT a.amount_mc,
+                     a.expires_at,
+                     COALESCE(SUM(a.amount_mc) OVER (
+                       ORDER BY a.expires_at ASC, a.lot_id ASC
+                       ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+                     ), 0) AS prior_mc
+              FROM billing_debit_allocations a
+              WHERE a.debit_idempotency_key = ?
+            ), refunds AS (
+              SELECT expires_at,
+                     amount_mc - MIN(amount_mc, MAX(0, ? - prior_mc)) AS refund_mc
+              FROM ordered
+            )
+            SELECT (SELECT COUNT(*) FROM ordered) AS allocation_count,
+                   COALESCE(SUM(CASE WHEN expires_at > ? THEN refund_mc ELSE 0 END), 0) AS credited_refund_mc
+            FROM refunds`,
+      args: [debitIdempotencyKey, durableFinalAmountMc, String(row.settled_at)]
+    });
+    const allocationCount = Number(allocationRefund.rows[0]?.allocation_count ?? 0);
+    const creditedRefundMc = allocationCount > 0 ? Number(allocationRefund.rows[0]?.credited_refund_mc ?? 0) : 0;
+    const balance = await db.execute({ sql: "SELECT balance_mc FROM users WHERE id = ?", args: [userId] });
+    return {
+      balance_mc: Number(balance.rows[0]?.balance_mc ?? 0),
+      final_amount_mc: durableFinalAmountMc,
+      refund_mc: creditedRefundMc,
+      expired_refund_mc: nominalRefundMc - creditedRefundMc,
+      duplicate: true
+    };
+  };
+  let results;
+  try {
+    results = await db.batch([
+      {
+        sql: `INSERT OR IGNORE INTO billing_events
+                (id, user_id, idempotency_key, billing_class, source_surface, status, amount_mc, metadata)
+              VALUES (?, ?, ?, ?, ?, 'settling', ?, ?)`,
+        args: [eventId, userId, settlementKey, billingClass, sourceSurface, finalAmountMc, metadata]
+      },
+      {
+        sql: `WITH ordered AS (
+                SELECT a.lot_id,
+                       a.amount_mc,
+                       a.expires_at,
+                       COALESCE(SUM(a.amount_mc) OVER (
+                         ORDER BY a.expires_at ASC, a.lot_id ASC
+                         ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+                       ), 0) AS prior_mc
+                FROM billing_debit_allocations a
+                WHERE a.debit_idempotency_key = ?
+              ), refunds AS (
+                SELECT lot_id,
+                       expires_at,
+                       amount_mc - MIN(amount_mc, MAX(0, ? - prior_mc)) AS refund_mc
+                FROM ordered
+              )
+              UPDATE users
+              SET balance_mc = balance_mc + CASE
+                WHEN EXISTS (SELECT 1 FROM ordered) THEN COALESCE(
+                  (SELECT SUM(refund_mc) FROM refunds WHERE expires_at > datetime('now')),
+                  0
+                )
+                -- Holds created before allocation provenance cannot be safely
+                -- tied back to a source lot. Treat their unused portion as
+                -- expired instead of minting spendable credits with a guessed
+                -- expiry.
+                ELSE 0
+              END
+              WHERE id = ?
+                AND EXISTS (
+                  SELECT 1
+                  FROM billing_events e
+                  JOIN billing_debits d ON d.idempotency_key = ?
+                  WHERE e.idempotency_key = ?
+                    AND e.user_id = ?
+                    AND e.billing_class = ?
+                    AND e.source_surface = ?
+                    AND e.status = 'settling'
+                    AND d.user_id = e.user_id
+                    AND d.status = 'applied'
+                    AND e.amount_mc BETWEEN 0 AND d.amount_mc
+                )`,
+        args: [
+          debitIdempotencyKey,
+          finalAmountMc,
+          userId,
+          debitIdempotencyKey,
+          settlementKey,
+          userId,
+          billingClass,
+          sourceSurface
+        ]
+      },
+      {
+        sql: `UPDATE billing_events
+              SET status = 'applying'
+              WHERE idempotency_key = ?
+                AND user_id = ?
+                AND billing_class = ?
+                AND source_surface = ?
+                AND status = 'settling'
+                AND changes() = 1`,
+        args: [settlementKey, userId, billingClass, sourceSurface]
+      },
+      {
+        sql: `WITH ordered AS (
+                SELECT a.lot_id,
+                       a.amount_mc,
+                       a.expires_at,
+                       COALESCE(SUM(a.amount_mc) OVER (
+                         ORDER BY a.expires_at ASC, a.lot_id ASC
+                         ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+                       ), 0) AS prior_mc
+                FROM billing_debit_allocations a
+                WHERE a.debit_idempotency_key = ?
+              ), refunds AS (
+                SELECT lot_id,
+                       expires_at,
+                       amount_mc - MIN(amount_mc, MAX(0, ? - prior_mc)) AS refund_mc
+                FROM ordered
+              )
+              UPDATE credit_lots
+              SET remaining_mc = remaining_mc + COALESCE((SELECT refund_mc FROM refunds WHERE refunds.lot_id = credit_lots.id), 0)
+              WHERE id IN (
+                SELECT lot_id FROM refunds
+                WHERE refund_mc > 0 AND expires_at > datetime('now')
+              )
+                AND EXISTS (SELECT 1 FROM billing_events WHERE idempotency_key = ? AND status = 'applying')`,
+        args: [debitIdempotencyKey, finalAmountMc, settlementKey]
+      },
+      {
+        sql: `WITH ordered AS (
+                SELECT a.amount_mc,
+                       a.expires_at,
+                       COALESCE(SUM(a.amount_mc) OVER (
+                         ORDER BY a.expires_at ASC, a.lot_id ASC
+                         ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+                       ), 0) AS prior_mc
+                FROM billing_debit_allocations a
+                WHERE a.debit_idempotency_key = ?
+              ), refunds AS (
+                SELECT expires_at,
+                       amount_mc - MIN(amount_mc, MAX(0, ? - prior_mc)) AS refund_mc
+                FROM ordered
+              ), credited AS (
+                SELECT e.user_id,
+                       CASE
+                         WHEN EXISTS (SELECT 1 FROM ordered) THEN COALESCE(
+                           (SELECT SUM(refund_mc) FROM refunds WHERE expires_at > datetime('now')),
+                           0
+                         )
+                         ELSE 0
+                       END AS refund_mc
+                FROM billing_events e
+                JOIN billing_debits d ON d.idempotency_key = ?
+                WHERE e.idempotency_key = ?
+                  AND e.status = 'applying'
+              )
+              INSERT INTO ledger (user_id, amount_mc, operation, description)
+              SELECT user_id,
+                     refund_mc,
+                     ?,
+                     ?
+              FROM credited
+              WHERE refund_mc > 0`,
+        args: [
+          debitIdempotencyKey,
+          finalAmountMc,
+          debitIdempotencyKey,
+          settlementKey,
+          refundOperation,
+          description
+        ]
+      },
+      {
+        sql: `UPDATE billing_events
+              SET status = 'settled', settled_at = datetime('now')
+              WHERE idempotency_key = ?
+                AND status = 'applying'`,
+        args: [settlementKey]
+      }
+    ], "write");
+  } catch (error) {
+    try {
+      const recovered = await readReceipt();
+      if (recovered) return recovered;
+    } catch {
+    }
+    throw error;
+  }
+  const receipt = await readReceipt();
+  if (!receipt) throw new Error("idempotent debit settlement did not reach a durable settled state");
+  return { ...receipt, duplicate: results[0]?.rowsAffected === 0 };
+}
+async function getLedger(userId, limit = 50) {
+  const res = await getDb().execute({
+    sql: "SELECT * FROM ledger WHERE user_id = ? ORDER BY created_at DESC LIMIT ?",
+    args: [userId, limit]
+  });
+  return res.rows.map((r) => ({
+    id: Number(r.id),
+    user_id: Number(r.user_id),
+    amount_mc: Number(r.amount_mc),
+    operation: String(r.operation),
+    description: r.description != null ? String(r.description) : null,
+    stripe_pi: r.stripe_pi != null ? String(r.stripe_pi) : null,
+    created_at: String(r.created_at)
+  }));
+}
+async function getBillingLedgerSummary(userId, since, classification) {
+  const db = getDb();
+  const refundPlaceholders = classification.refund.map(() => "?").join(", ");
+  const grantPlaceholders = classification.grant.map(() => "?").join(", ");
+  const purchasePlaceholders = classification.purchase.map(() => "?").join(", ");
+  const totalsRes = await db.execute({
+    sql: `SELECT
+      COALESCE(SUM(CASE WHEN amount_mc < 0 AND operation NOT IN (${refundPlaceholders}) THEN -amount_mc ELSE 0 END), 0) AS spent_mc,
+      COALESCE(SUM(CASE WHEN amount_mc > 0 AND operation IN (${refundPlaceholders}) THEN amount_mc ELSE 0 END), 0) AS refunded_mc,
+      COALESCE(SUM(CASE WHEN amount_mc > 0 AND operation IN (${grantPlaceholders}) THEN amount_mc ELSE 0 END), 0) AS granted_mc,
+      COALESCE(SUM(CASE WHEN amount_mc > 0 AND operation IN (${purchasePlaceholders}) THEN amount_mc ELSE 0 END), 0) AS purchased_mc,
+      COALESCE(SUM(amount_mc), 0) AS net_mc
+      FROM ledger WHERE user_id = ? AND created_at >= ?`,
+    args: [
+      ...classification.refund,
+      ...classification.refund,
+      ...classification.grant,
+      ...classification.purchase,
+      userId,
+      since
+    ]
+  });
+  const byOpRes = await db.execute({
+    sql: `SELECT operation, -SUM(amount_mc) AS mc, COUNT(*) AS count
+      FROM ledger
+      WHERE user_id = ? AND created_at >= ? AND amount_mc < 0 AND operation NOT IN (${refundPlaceholders})
+      GROUP BY operation
+      ORDER BY mc DESC, operation ASC`,
+    args: [userId, since, ...classification.refund]
+  });
+  const totals = totalsRes.rows[0];
+  return {
+    spent_mc: Number(totals?.spent_mc ?? 0),
+    refunded_mc: Number(totals?.refunded_mc ?? 0),
+    granted_mc: Number(totals?.granted_mc ?? 0),
+    purchased_mc: Number(totals?.purchased_mc ?? 0),
+    net_mc: Number(totals?.net_mc ?? 0),
+    by_operation: byOpRes.rows.map((r) => ({
+      operation: String(r.operation),
+      mc: Number(r.mc),
+      count: Number(r.count)
+    }))
+  };
+}
+async function ledgerExistsForStripePI(stripePI) {
+  const res = await getDb().execute({
+    sql: "SELECT 1 FROM ledger WHERE stripe_pi = ? LIMIT 1",
+    args: [stripePI]
+  });
+  return res.rows.length > 0;
+}
+async function reconcileBalanceMc(userId, knownBalanceMc) {
+  const db = getDb();
+  void knownBalanceMc;
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const snapshot = await db.execute({
+      sql: `SELECT
+              u.balance_mc AS cached_balance_mc,
+              COUNT(l.id) AS lot_count,
+              COALESCE(SUM(CASE
+                WHEN l.remaining_mc > 0
+                  AND (l.never_expires = 1 OR l.expires_at > datetime('now'))
+                THEN l.remaining_mc ELSE 0 END), 0) AS projected_balance_mc
+            FROM users u
+            LEFT JOIN credit_lots l ON l.user_id = u.id
+            WHERE u.id = ?
+            GROUP BY u.id, u.balance_mc`,
+      args: [userId]
+    });
+    const row = snapshot.rows[0];
+    if (!row) return 0;
+    if (Number(row.lot_count ?? 0) === 0) {
+      await ensureMigrated(Number(userId));
+      const nowHasLots = await db.execute({
+        sql: "SELECT 1 FROM credit_lots WHERE user_id = ? LIMIT 1",
+        args: [userId]
+      });
+      if (nowHasLots.rows.length > 0) continue;
+    }
+    const cachedBalanceMc = Number(row.cached_balance_mc ?? 0);
+    const projectedBalanceMc = Number(row.projected_balance_mc ?? 0);
+    if (cachedBalanceMc === projectedBalanceMc) return projectedBalanceMc;
+    const updated = await db.execute({
+      sql: "UPDATE users SET balance_mc = ? WHERE id = ? AND balance_mc = ?",
+      args: [projectedBalanceMc, userId, cachedBalanceMc]
+    });
+    if (updated.rowsAffected === 1) return projectedBalanceMc;
+  }
+  const current = await db.execute({
+    sql: "SELECT balance_mc FROM users WHERE id = ? LIMIT 1",
+    args: [userId]
+  });
+  return Number(current.rows[0]?.balance_mc ?? 0);
+}
+var SiteAuditJobRowSchema = z.object({
+  id: z.string(),
+  user_id: z.number(),
+  status: z.string().default("pending"),
+  client_domain: z.string(),
+  session_path: z.string(),
+  request: z.string(),
+  result: z.string().nullable(),
+  error: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var SiteAuditPhaseLogRowSchema = z.object({
+  id: z.number(),
+  job_id: z.string(),
+  phase: z.string(),
+  completed_at: z.string(),
+  output_summary: z.string()
+});
+async function listInboxMessages(userId) {
+  const res = await getDb().execute({
+    sql: "SELECT id, subject, sent_at, opened_at FROM inbox_messages WHERE user_id = ? AND deleted_at IS NULL ORDER BY sent_at DESC, id DESC",
+    args: [userId]
+  });
+  return res.rows.map((r) => ({
+    id: String(r.id),
+    subject: String(r.subject),
+    sent_at: String(r.sent_at),
+    opened_at: r.opened_at != null ? String(r.opened_at) : null
+  }));
+}
+async function getInboxMessage(userId, id) {
+  const res = await getDb().execute({
+    sql: "SELECT id, subject, body_md, source, sent_at, opened_at FROM inbox_messages WHERE id = ? AND user_id = ? AND deleted_at IS NULL",
+    args: [id, userId]
+  });
+  const row = res.rows[0];
+  if (!row) return void 0;
+  return {
+    id: String(row.id),
+    subject: String(row.subject),
+    body_md: String(row.body_md),
+    source: String(row.source),
+    sent_at: String(row.sent_at),
+    opened_at: row.opened_at != null ? String(row.opened_at) : null
+  };
+}
+async function markInboxMessageOpened(userId, id) {
+  const db = getDb();
+  await db.execute({
+    sql: "UPDATE inbox_messages SET opened_at = datetime('now') WHERE id = ? AND user_id = ? AND deleted_at IS NULL AND opened_at IS NULL",
+    args: [id, userId]
+  });
+  const res = await db.execute({
+    sql: "SELECT opened_at FROM inbox_messages WHERE id = ? AND user_id = ? AND deleted_at IS NULL",
+    args: [id, userId]
+  });
+  const row = res.rows[0];
+  if (!row) return null;
+  return row.opened_at != null ? String(row.opened_at) : null;
+}
+async function softDeleteInboxMessage(userId, id) {
+  const res = await getDb().execute({
+    sql: "UPDATE inbox_messages SET deleted_at = datetime('now') WHERE id = ? AND user_id = ? AND deleted_at IS NULL",
+    args: [id, userId]
+  });
+  return res.rowsAffected > 0;
+}
+async function insertInboxMessage(userId, subject, bodyMd, source = "operator") {
+  const id = randomUUID();
+  await getDb().execute({
+    sql: "INSERT INTO inbox_messages (id, user_id, subject, body_md, source) VALUES (?, ?, ?, ?, ?)",
+    args: [id, userId, subject, bodyMd, source]
+  });
+  return id;
+}
+async function listActiveUserIds() {
+  const res = await getDb().execute("SELECT id FROM users WHERE active = 1");
+  return res.rows.map((r) => Number(r.id));
+}
+
+export {
+  CREDIT_LOTS_EPOCH,
+  CORE_SCHEMA_VERSION,
+  getDb,
+  setDbForTesting,
+  migrate,
+  registerClient,
+  getClient,
+  putCode,
+  consumeCode,
+  putRefresh,
+  getRefresh,
+  revokeRefresh,
+  rotateRefresh,
+  claimStripeEvent,
+  completeStripeEvent,
+  failStripeEvent,
+  stripeEventAlreadyProcessed,
+  generateApiKey,
+  hashPassword,
+  verifyPassword,
+  getUserByEmail,
+  getUserByApiKey,
+  getUserById,
+  getUserMemoryCreds,
+  setUserMemoryCreds,
+  setPassword,
+  getUserStats,
+  createUser,
+  checkRateLimit,
+  createPasswordResetToken,
+  consumePasswordResetToken,
+  rotateApiKey,
+  revokeApiKey,
+  listUsers,
+  deactivateUser,
+  createJob,
+  createRunningJob,
+  startHarvestAttempt,
+  finishHarvestAttempt,
+  listHarvestAttempts,
+  getJob,
+  listJobs,
+  getPageSnapshot,
+  upsertPageSnapshot,
+  logRequestEvent,
+  listRequestEvents,
+  createWorkflowSchedule,
+  getWorkflowSchedule,
+  listWorkflowSchedules,
+  patchWorkflowSchedule,
+  deleteWorkflowSchedule,
+  listDueWorkflowSchedules,
+  markWorkflowScheduleRan,
+  createWorkflowRun,
+  getWorkflowRun,
+  getWorkflowRunByIdempotencyKey,
+  listWorkflowRuns,
+  markWorkflowRunRunning,
+  completeWorkflowRunRecord,
+  failWorkflowRunRecord,
+  replaceWorkflowArtifacts,
+  appendWorkflowArtifacts,
+  getWorkflowRunStepState,
+  advanceWorkflowRunStep,
+  listWorkflowArtifacts,
+  getWorkflowArtifact,
+  recordWorkflowWebhookDelivery,
+  countActiveUsers,
+  countActiveJobsForUser,
+  claimPendingJob,
+  completeJob,
+  failJob,
+  cancelJob,
+  createKpoJob,
+  claimPendingKpoJob,
+  getKpoJob,
+  updateKpoJobState,
+  completeKpoJob,
+  failKpoJob,
+  logKpoPhaseComplete,
+  getKpoPhaseLog,
+  listKpoJobs,
+  getUserByStripeCustomerId,
+  setStripeCustomerId,
+  setExtraConcurrencySlots,
+  setConcurrencySubId,
+  setSubscriptionTier,
+  getConnectedAccountBillingState,
+  setConnectedAccountBillingState,
+  listUsersDueForConnectedAccountBillingReconciliation,
+  setMemoryPlan,
+  getMemoryPlan,
+  getMemoryProvisioned,
+  setMemoryProvisioned,
+  resolveUserByMemorySubscription,
+  CREDIT_LOT_TTL,
+  expireOldLots,
+  migrateExistingBalancesToLots,
+  creditMc,
+  creditMcIdempotent,
+  ledgerExistsForOperation,
+  claimMonthlyFreeRefresh,
+  debitMc,
+  debitMcIdempotent,
+  settleDebitMcIdempotent,
+  getLedger,
+  getBillingLedgerSummary,
+  ledgerExistsForStripePI,
+  reconcileBalanceMc,
+  SiteAuditJobRowSchema,
+  SiteAuditPhaseLogRowSchema,
+  listInboxMessages,
+  getInboxMessage,
+  markInboxMessageOpened,
+  softDeleteInboxMessage,
+  insertInboxMessage,
+  listActiveUserIds
+};
+//# sourceMappingURL=chunk-GUVKHCKE.js.map