mcp-scraper 0.88.2 → 0.89.0

package/dist/chunk-YXNDOQXN.js

@@ -1,4018 +0,0 @@
-// 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/errors.ts
-var RECAPTCHA_INSTRUCTIONS = "Google returned a CAPTCHA. Run with --headless=false to re-warm the browser profile, then retry.";
-var PUBLIC_SERVICE_UNAVAILABLE_MESSAGE = "This operation is temporarily unavailable. Please retry later.";
-var PUBLIC_ERROR_CODES = [
-  "request_aborted",
-  "captcha_exhausted",
-  "captcha_or_blocked",
-  "location_mismatch",
-  "proxy_tunnel_failed",
-  "proxy_unavailable",
-  "harvest_timeout",
-  "mcp_request_timeout",
-  "mcp_http_error",
-  "extraction_failed",
-  "concurrency_limit_exceeded",
-  "unauthorized",
-  "forbidden",
-  "invalid_request",
-  "rate_limited",
-  "upstream_rate_limited",
-  "insufficient_balance",
-  "service_unavailable",
-  "response_lost",
-  "vendor_unavailable",
-  "page_not_found",
-  "page_forbidden",
-  "page_rate_limited",
-  "page_server_error",
-  "page_http_error",
-  "bot_check_unresolved",
-  "page_too_large",
-  "page_unreachable",
-  "browser_session_interrupted",
-  "site_export_not_found",
-  "site_export_format_unavailable",
-  "site_export_read_failed",
-  "site_export_image_not_found",
-  "image_url_invalid",
-  "image_url_not_https",
-  "image_host_unresolvable",
-  "image_host_blocked",
-  "image_redirect_invalid",
-  "image_source_unavailable",
-  "image_too_large",
-  "image_redirect_limit",
-  "image_base64_invalid",
-  "image_source_missing",
-  "image_source_ambiguous",
-  "image_source_type_invalid",
-  "image_artifact_not_found",
-  "image_page_too_large",
-  "page_image_not_found",
-  "page_image_candidates_unusable",
-  "image_format_unsupported",
-  "image_storage_unconfigured",
-  "featured_image_unhostable"
-];
-var PUBLIC_ERROR_TYPES = [
-  "request_aborted",
-  "captcha",
-  "location_mismatch",
-  "connection",
-  "timeout",
-  "extraction",
-  "concurrency_limit",
-  "unauthorized",
-  "forbidden",
-  "invalid_request",
-  "rate_limit",
-  "billing",
-  "service_unavailable"
-];
-function serializePublicErrorEnvelope(envelope) {
-  return envelope ? JSON.stringify(envelope) : null;
-}
-function parsePublicErrorEnvelope(value) {
-  if (value == null) return null;
-  try {
-    const parsed = typeof value === "string" ? JSON.parse(value) : value;
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-    const row = parsed;
-    if (typeof row.error_code !== "string" || !PUBLIC_ERROR_CODE_SET.has(row.error_code)) return null;
-    const envelope = buildPublicErrorEnvelope({
-      errorCode: row.error_code,
-      errorType: row.error_type,
-      retryable: row.retryable,
-      retryAfterSeconds: row.retry_after_seconds,
-      chargeStatus: row.charge_status,
-      details: row.details
-    });
-    if (typeof row.message === "string") {
-      const message = sanitizeVendorName(row.message).trim().slice(0, 1e3);
-      if (message && !/https?:\/\//i.test(message)) envelope.message = message;
-    }
-    return envelope;
-  } catch {
-    return null;
-  }
-}
-var PUBLIC_ERROR_CODE_SET = new Set(PUBLIC_ERROR_CODES);
-var PUBLIC_ERROR_TYPE_SET = new Set(PUBLIC_ERROR_TYPES);
-var PUBLIC_DETAIL_KEYS = /* @__PURE__ */ new Set([
-  "active",
-  "limit",
-  "operation",
-  "upgrade_url",
-  "topup_url",
-  "upgrade_command",
-  "slots_per_pack",
-  "pack_price_usd",
-  "balance_credits",
-  "required_credits",
-  "retry_guidance",
-  "http_status"
-]);
-var MAX_PUBLIC_DETAILS = 12;
-var MAX_PUBLIC_DETAIL_TEXT = 500;
-function normalizePublicErrorCode(code) {
-  return typeof code === "string" && PUBLIC_ERROR_CODE_SET.has(code) ? code : "service_unavailable";
-}
-function sanitizePublicErrorDetails(details) {
-  if (!details || typeof details !== "object" || Array.isArray(details)) return void 0;
-  const safe = {};
-  for (const [key, value] of Object.entries(details)) {
-    if (Object.keys(safe).length >= MAX_PUBLIC_DETAILS) break;
-    if (!PUBLIC_DETAIL_KEYS.has(key)) continue;
-    if (typeof value === "string") {
-      if ((key === "upgrade_url" || key === "topup_url") && !isSafePublicAccountUrl(value)) continue;
-      const sanitized = sanitizeVendorName(value).slice(0, MAX_PUBLIC_DETAIL_TEXT);
-      if (sanitized) safe[key] = sanitized;
-    } else if (typeof value === "number" && Number.isFinite(value)) safe[key] = value;
-    else if (typeof value === "boolean" || value === null) safe[key] = value;
-  }
-  return Object.keys(safe).length > 0 ? safe : void 0;
-}
-function isSafePublicAccountUrl(value) {
-  if (value.startsWith("/") && !value.startsWith("//")) return true;
-  try {
-    const url = new URL(value);
-    return url.protocol === "https:" && (url.hostname === "mcpscraper.dev" || url.hostname.endsWith(".mcpscraper.dev"));
-  } catch {
-    return false;
-  }
-}
-function publicErrorType(code) {
-  const publicCode = normalizePublicErrorCode(code);
-  switch (publicCode) {
-    case "captcha_exhausted":
-    case "captcha_or_blocked":
-      return "captcha";
-    case "proxy_tunnel_failed":
-    case "proxy_unavailable":
-    case "response_lost":
-      return "connection";
-    case "harvest_timeout":
-    case "mcp_request_timeout":
-      return "timeout";
-    case "concurrency_limit_exceeded":
-      return "concurrency_limit";
-    case "rate_limited":
-    case "upstream_rate_limited":
-      return "rate_limit";
-    case "extraction_failed":
-    case "page_not_found":
-    case "page_forbidden":
-    case "page_rate_limited":
-    case "page_server_error":
-    case "page_http_error":
-    case "bot_check_unresolved":
-    case "page_too_large":
-    case "page_unreachable":
-    case "browser_session_interrupted":
-    case "site_export_not_found":
-    case "site_export_format_unavailable":
-    case "site_export_read_failed":
-    case "site_export_image_not_found":
-      return "extraction";
-    case "image_url_invalid":
-    case "image_url_not_https":
-    case "image_host_unresolvable":
-    case "image_host_blocked":
-    case "image_redirect_invalid":
-    case "image_source_unavailable":
-    case "image_too_large":
-    case "image_redirect_limit":
-    case "image_base64_invalid":
-    case "image_source_missing":
-    case "image_source_ambiguous":
-    case "image_source_type_invalid":
-    case "image_artifact_not_found":
-    case "image_page_too_large":
-    case "page_image_not_found":
-    case "page_image_candidates_unusable":
-    case "image_format_unsupported":
-    case "image_storage_unconfigured":
-    case "featured_image_unhostable":
-      return "invalid_request";
-    case "insufficient_balance":
-      return "billing";
-    case "vendor_unavailable":
-    case "mcp_http_error":
-      return "service_unavailable";
-    default:
-      return publicCode;
-  }
-}
-function publicErrorMessage(code) {
-  switch (normalizePublicErrorCode(code)) {
-    case "request_aborted":
-      return "The request was cancelled before it completed.";
-    case "captcha_exhausted":
-    case "captcha_or_blocked":
-      return "The target site returned a verification challenge. Heavy traffic can temporarily increase these challenges; retry in a few minutes.";
-    case "location_mismatch":
-      return "The target site returned results for a different location. Please retry.";
-    case "proxy_tunnel_failed":
-    case "proxy_unavailable":
-      return "The web request could not establish a working connection. Please retry later.";
-    case "harvest_timeout":
-      return "The request timed out before it completed. Please retry with a smaller request.";
-    case "mcp_request_timeout":
-      return "The MCP caller stopped waiting before a final response arrived. Durable work may still be running; continue with the returned Task or job handle instead of restarting it.";
-    case "concurrency_limit_exceeded":
-      return "The service is available, but this account has reached its parallel-operation limit. Wait for an active operation to finish or add capacity.";
-    case "unauthorized":
-      return "Authentication is required to perform this operation.";
-    case "forbidden":
-      return "This account does not have permission to perform this operation.";
-    case "invalid_request":
-      return "The request is invalid. Check the supplied inputs and try again.";
-    case "rate_limited":
-      return "This account is sending requests too quickly. Wait briefly and retry.";
-    case "upstream_rate_limited":
-      return "The connected provider is temporarily rate-limiting requests. Wait briefly and retry.";
-    case "mcp_http_error":
-      return "The API returned an unexpected HTTP response.";
-    case "insufficient_balance":
-      return "This account does not have enough Credits for the operation.";
-    case "extraction_failed":
-      return "The target could not be extracted. Please retry later.";
-    case "response_lost":
-      return "The connection was lost before the response arrived. The operation may have already completed and been billed on our side \u2014 check credits_info before retrying blind.";
-    case "vendor_unavailable":
-      return "MCP Scraper's internal browser services require MCP Scraper team attention. Servers or IPs are down until this is fixed \u2014 this is not caused by your request. Please retry in a few minutes.";
-    case "page_not_found":
-      return "The page could not be found. It may have been moved or deleted.";
-    case "page_forbidden":
-      return "The site refused the request.";
-    case "page_rate_limited":
-      return "The site is rate-limiting requests right now. Retrying after a short wait usually works.";
-    case "page_server_error":
-      return "The page's own server returned an error. This is on the target site's side, not something a retry here can fix.";
-    case "page_http_error":
-      return "The page returned an unexpected HTTP response.";
-    case "bot_check_unresolved":
-      return "This site has automated-traffic protection (a bot/CAPTCHA check) that could not be resolved in time. Some sites are simply not extractable this way.";
-    case "page_too_large":
-      return "The page is larger than we can safely process.";
-    case "page_unreachable":
-      return "The page did not respond in time, or the connection could not be completed.";
-    case "browser_session_interrupted":
-      return "The browser session closed before extraction completed. MCP Scraper will retry once with a fresh session; retry the request if this persists.";
-    case "site_export_not_found":
-      return "The site export or requested page was not found, expired, or does not belong to this account.";
-    case "site_export_format_unavailable":
-      return "That representation was not retained for this export page. Read the export manifest and request one of the formats marked available.";
-    case "site_export_read_failed":
-      return "The stored site export could not be read or did not pass its integrity check.";
-    case "site_export_image_not_found":
-      return "The requested site-export image was not found, expired, or does not belong to this account.";
-    case "image_url_invalid":
-      return "The image source is not a valid URL. Use a stable public HTTPS URL or inline image bytes.";
-    case "image_url_not_https":
-      return "Commons image sources must use a public HTTPS URL or inline image bytes.";
-    case "image_host_unresolvable":
-      return "The image host could not be resolved. Use a different stable public URL or inline image bytes.";
-    case "image_host_blocked":
-      return "The image source resolves to a network address Commons cannot fetch safely.";
-    case "image_redirect_invalid":
-      return "The image source redirected to an invalid or unsafe destination.";
-    case "image_source_unavailable":
-      return "The image source could not be fetched. Host a different stable public URL or provide inline image bytes.";
-    case "image_too_large":
-      return "The image exceeds the Commons image size limit.";
-    case "image_redirect_limit":
-      return "The image source exceeded the Commons redirect limit.";
-    case "image_base64_invalid":
-      return "The supplied inline image bytes are invalid.";
-    case "image_source_missing":
-      return "Provide exactly one of a public image or webpage URL, inline image bytes, or an owner-scoped image artifact.";
-    case "image_source_ambiguous":
-      return "Provide only one image source: sourceUrl, imageBase64, or artifactId.";
-    case "image_source_type_invalid":
-      return "Use sourceType only with inline image bytes or an owner-scoped image artifact.";
-    case "image_artifact_not_found":
-      return "The image artifact was not found, expired, or does not belong to this account.";
-    case "image_page_too_large":
-      return "The webpage is too large for bounded Commons image discovery.";
-    case "page_image_not_found":
-      return "The webpage did not expose a usable featured or content image.";
-    case "page_image_candidates_unusable":
-      return "The webpage exposed image candidates, but none returned supported public image bytes.";
-    case "image_format_unsupported":
-      return "Commons accepts JPEG, PNG, GIF, or WebP image bytes.";
-    case "image_storage_unconfigured":
-      return "Commons image storage is temporarily unavailable.";
-    case "featured_image_unhostable":
-      return "The required featured image could not be hosted for Commons publication.";
-    default:
-      return PUBLIC_SERVICE_UNAVAILABLE_MESSAGE;
-  }
-}
-function buildPublicErrorEnvelope(input) {
-  const errorCode = normalizePublicErrorCode(input.errorCode);
-  const retryAfter = typeof input.retryAfterSeconds === "number" && Number.isFinite(input.retryAfterSeconds) ? Math.max(1, Math.min(86400, Math.trunc(input.retryAfterSeconds))) : void 0;
-  const chargeStatus = input.chargeStatus === "not_charged" || input.chargeStatus === "refund_pending" || input.chargeStatus === "refunded" || input.chargeStatus === "charged" ? input.chargeStatus : void 0;
-  const requestedType = typeof input.errorType === "string" && PUBLIC_ERROR_TYPE_SET.has(input.errorType) ? input.errorType : void 0;
-  const details = sanitizePublicErrorDetails(input.details);
-  return {
-    error_code: errorCode,
-    error_type: requestedType ?? publicErrorType(errorCode),
-    message: publicErrorMessage(errorCode),
-    retryable: input.retryable === true,
-    ...retryAfter ? { retry_after_seconds: retryAfter } : {},
-    ...chargeStatus ? { charge_status: chargeStatus } : {},
-    ...details ? { details } : {}
-  };
-}
-function sanitizeVendorName(message) {
-  return message.replace(/https?:\/\/[^\s]*(?:brightdata|onkernel|kernel\.sh)[^\s]*/gi, "the service").replace(/bright\s*data/gi, "the service").replace(/brightdata/gi, "the service").replace(/kernel\.sh\s+sessions?/gi, "sessions").replace(/kernel\.sh\s+session/gi, "this session").replace(/kernel\.sh/gi, "the service").replace(/kernel\s+sessions?/gi, "sessions").replace(/kernel\s+session/gi, "this session").replace(/\b(?:sub|cus|sess|proxy)_[A-Za-z0-9_-]+\b/g, "[redacted]").replace(/\b(?:KERNEL|BRIGHTDATA|BRIGHT_DATA)_[A-Z0-9_]*API_KEY\b/g, "BROWSER_SERVICE_API_KEY").replace(/\bkernel\b/gi, "the service").replace(/  +/g, " ").trim();
-}
-var CaptchaError = class extends Error {
-  constructor(instructions) {
-    super(`CAPTCHA detected. ${instructions}`);
-    this.instructions = instructions;
-  }
-  instructions;
-  name = "CaptchaError";
-};
-var ExtractionError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-  }
-  cause;
-  name = "ExtractionError";
-};
-var MapsSearchIncompletePageError = class extends Error {
-  constructor(pageState) {
-    super(`Google Maps search did not reach a complete result state (${pageState})`);
-    this.pageState = pageState;
-  }
-  pageState;
-  name = "MapsSearchIncompletePageError";
-};
-var RequestAbortedError = class extends Error {
-  name = "RequestAbortedError";
-  constructor(message = "Request aborted before harvest completed") {
-    super(message);
-  }
-};
-var PaaInteractionInterruptedError = class extends Error {
-  name = "PaaInteractionInterruptedError";
-};
-var LocationMismatchError = class extends Error {
-  name = "LocationMismatchError";
-  constructor(message = "Google returned results for a different location than requested") {
-    super(message);
-  }
-};
-
-// 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-08-27.1";
-var SITE_EXTRACT_COUNTER_REPAIR_VERSION = "data-2026-07-28-site-extract-counters.1";
-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",
-  "scheduled_run_view_links",
-  "serp_identities",
-  "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_active_user",
-  "concurrency_locks_operation",
-  "concurrency_locks_user_status",
-  "credit_lots_user_active",
-  "credit_lot_repairs_user_applied",
-  "harvest_attempts_job_id",
-  "harvest_attempts_provider_lookup",
-  "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_created_at",
-  "request_events_user_created_at",
-  "scheduled_run_view_links_expiry",
-  "scheduled_run_view_links_owner_run",
-  "serp_identities_user_name",
-  "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",
-    "browser_provider",
-    "provider_session_id",
-    "provider_session_observed_at",
-    "provider_lookup_status",
-    "provider_status",
-    "provider_error_code",
-    "provider_error_message",
-    "provider_reason_source",
-    "provider_duration_ms",
-    "provider_bandwidth_bytes",
-    "provider_captcha",
-    "provider_checked_at",
-    "provider_detail_json",
-    "provider_disconnect_observed",
-    "provider_disconnect_message"
-  ],
-  jobs: ["public_error_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",
-    "public_error_json"
-  ],
-  stripe_events: ["attempt_count", "claim_token", "last_error", "status", "updated_at"],
-  users: [
-    "balance_mc",
-    "concurrency_stripe_sub_id",
-    "concurrency_pack_quantity",
-    "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 runSiteExtractCounterRepair(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
-  `);
-}
-async function runPendingDataRepairs(db) {
-  const applied = await db.execute({
-    sql: "SELECT 1 AS applied FROM schema_migrations WHERE version = ? LIMIT 1",
-    args: [SITE_EXTRACT_COUNTER_REPAIR_VERSION]
-  });
-  if (applied.rows.length > 0) return;
-  await runSiteExtractCounterRepair(db);
-  await db.execute({
-    sql: "INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)",
-    args: [SITE_EXTRACT_COUNTER_REPAIR_VERSION]
-  });
-}
-function getDb() {
-  if (!_db) _db = createClient({ url: DB_URL, authToken: DB_TOKEN });
-  return _db;
-}
-function setDbForTesting(client) {
-  _db = client;
-}
-async function migrate(options = {}) {
-  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) {
-    if (!options.verifyCurrentSchema) return;
-    if (await hasCurrentCoreSchema(db)) {
-      if (options.runDataRepairs) await runPendingDataRepairs(db);
-      return;
-    }
-  }
-  if (await hasCurrentCoreSchema(db)) {
-    await runPendingDataRepairs(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,
-      public_error_json 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)`);
-  try {
-    await db.execute(`ALTER TABLE jobs ADD COLUMN public_error_json TEXT`);
-  } catch {
-  }
-  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,
-      browser_provider         TEXT,
-      provider_session_id      TEXT,
-      provider_session_observed_at TEXT,
-      provider_lookup_status   TEXT,
-      provider_status          TEXT,
-      provider_error_code      TEXT,
-      provider_error_message   TEXT,
-      provider_reason_source   TEXT,
-      provider_duration_ms     INTEGER,
-      provider_bandwidth_bytes INTEGER,
-      provider_captcha         INTEGER,
-      provider_checked_at      TEXT,
-      provider_detail_json     TEXT,
-      provider_disconnect_observed INTEGER,
-      provider_disconnect_message 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 {
-  }
-  for (const column of [
-    "browser_provider TEXT",
-    "provider_session_id TEXT",
-    "provider_session_observed_at TEXT",
-    "provider_lookup_status TEXT",
-    "provider_status TEXT",
-    "provider_error_code TEXT",
-    "provider_error_message TEXT",
-    "provider_reason_source TEXT",
-    "provider_duration_ms INTEGER",
-    "provider_bandwidth_bytes INTEGER",
-    "provider_captcha INTEGER",
-    "provider_checked_at TEXT",
-    "provider_detail_json TEXT",
-    "provider_disconnect_observed INTEGER",
-    "provider_disconnect_message TEXT"
-  ]) {
-    try {
-      await db.execute(`ALTER TABLE harvest_attempts ADD COLUMN ${column}`);
-    } catch {
-    }
-  }
-  await db.execute(`CREATE INDEX IF NOT EXISTS harvest_attempts_provider_lookup ON harvest_attempts(browser_provider, provider_lookup_status, provider_checked_at)`);
-  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 concurrency_pack_quantity INTEGER NOT NULL DEFAULT 0`);
-  } 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 INDEX IF NOT EXISTS concurrency_locks_active_user ON concurrency_locks(user_id, expires_at) WHERE status = 'active'`);
-  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 connected_account_charges (
-      user_id       INTEGER NOT NULL,
-      connection_id TEXT NOT NULL,
-      period_start  TEXT NOT NULL,
-      amount_mc     INTEGER NOT NULL,
-      created_at    TEXT NOT NULL DEFAULT (datetime('now')),
-      PRIMARY KEY (user_id, connection_id, period_start)
-    )
-  `);
-  await db.execute(`
-    CREATE TABLE IF NOT EXISTS connected_account_charge_transfers (
-      id                 INTEGER PRIMARY KEY AUTOINCREMENT,
-      user_id            INTEGER NOT NULL,
-      period_start       TEXT NOT NULL,
-      from_connection_id TEXT NOT NULL,
-      to_connection_id   TEXT NOT NULL,
-      provider_config_key TEXT NOT NULL,
-      transferred_at     TEXT NOT NULL DEFAULT (datetime('now')),
-      UNIQUE (user_id, period_start, from_connection_id),
-      CHECK (from_connection_id <> to_connection_id)
-    )
-  `);
-  await db.execute(`CREATE INDEX IF NOT EXISTS connected_account_charge_transfers_destination ON connected_account_charge_transfers(user_id, period_start, to_connection_id, transferred_at DESC)`);
-  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,
-      public_error_json 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 {
-  }
-  try {
-    await db.execute(`ALTER TABLE site_extract_jobs ADD COLUMN public_error_json 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 INDEX IF NOT EXISTS request_events_created_at ON request_events(created_at)`);
-  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 scheduled_run_view_links (
-      share_id      TEXT PRIMARY KEY,
-      owner_id      TEXT NOT NULL,
-      run_id        TEXT NOT NULL,
-      artifact_id   TEXT NOT NULL,
-      title         TEXT NOT NULL,
-      summary       TEXT NOT NULL,
-      renderer_key  TEXT NOT NULL CHECK (renderer_key IN ('editorial_reading_room_v1','personal_authority_v1','personal_authority_v2','newsroom_publisher_v1','blog_article_v1')),
-      token_hash    TEXT NOT NULL UNIQUE,
-      expires_at    TEXT NOT NULL,
-      revoked_at    TEXT,
-      created_at    TEXT NOT NULL
-    )
-  `);
-  await db.execute(`
-    CREATE INDEX IF NOT EXISTS scheduled_run_view_links_owner_run
-    ON scheduled_run_view_links(owner_id, run_id, created_at DESC)
-  `);
-  await db.execute(`
-    CREATE INDEX IF NOT EXISTS scheduled_run_view_links_expiry
-    ON scheduled_run_view_links(expires_at, revoked_at)
-  `);
-  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)
-    )
-  `);
-  await db.execute(`
-    CREATE TABLE IF NOT EXISTS serp_identities (
-      id                  TEXT    PRIMARY KEY,
-      user_id             INTEGER NOT NULL REFERENCES users(id),
-      name                TEXT    NOT NULL,
-      kernel_profile_name TEXT    NOT NULL,
-      kernel_proxy_id     TEXT    NOT NULL,
-      proxy_type          TEXT    NOT NULL DEFAULT 'isp',
-      country             TEXT    NOT NULL DEFAULT 'US',
-      status              TEXT    NOT NULL DEFAULT 'ready',
-      created_at          TEXT    NOT NULL DEFAULT (datetime('now')),
-      updated_at          TEXT,
-      last_used_at        TEXT,
-      UNIQUE(user_id, name)
-    )
-  `);
-  await db.execute(`
-    CREATE UNIQUE INDEX IF NOT EXISTS serp_identities_user_name
-    ON serp_identities(user_id, name)
-  `);
-  if (!await hasCurrentCoreSchema(db)) {
-    throw new Error("core schema migration finished without all required tables, indexes, and columns");
-  }
-  await runPendingDataRepairs(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,
-    concurrency_pack_quantity: Number(row.concurrency_pack_quantity ?? 0),
-    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,
-    public_error_json: row.public_error_json != null ? String(row.public_error_json) : 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,
-    browser_provider: row.browser_provider != null ? String(row.browser_provider) : null,
-    provider_session_id: row.provider_session_id != null ? String(row.provider_session_id) : null,
-    provider_session_observed_at: row.provider_session_observed_at != null ? String(row.provider_session_observed_at) : null,
-    provider_lookup_status: row.provider_lookup_status != null ? String(row.provider_lookup_status) : null,
-    provider_status: row.provider_status != null ? String(row.provider_status) : null,
-    provider_error_code: row.provider_error_code != null ? String(row.provider_error_code) : null,
-    provider_error_message: row.provider_error_message != null ? String(row.provider_error_message) : null,
-    provider_reason_source: row.provider_reason_source != null ? String(row.provider_reason_source) : null,
-    provider_duration_ms: row.provider_duration_ms != null ? Number(row.provider_duration_ms) : null,
-    provider_bandwidth_bytes: row.provider_bandwidth_bytes != null ? Number(row.provider_bandwidth_bytes) : null,
-    provider_captcha: nullableBoolean(row.provider_captcha),
-    provider_checked_at: row.provider_checked_at != null ? String(row.provider_checked_at) : null,
-    provider_detail: parseNullableJson(row.provider_detail_json),
-    provider_disconnect_observed: nullableBoolean(row.provider_disconnect_observed),
-    provider_disconnect_message: row.provider_disconnect_message != null ? String(row.provider_disconnect_message) : 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) {
-  const { public_error_json: publicErrorJson, ...rest } = raw;
-  return {
-    ...rest,
-    options: JSON.parse(raw.options),
-    result: raw.result ? JSON.parse(raw.result) : null,
-    publicError: parsePublicErrorEnvelope(publicErrorJson)
-  };
-}
-async function createJob(userId, query, options, callbackUrl) {
-  const id = randomUUID();
-  await createJobWithId(id, userId, query, options, callbackUrl);
-  return id;
-}
-async function createJobWithId(id, userId, query, options, callbackUrl) {
-  if (!/^[a-zA-Z0-9-]{1,100}$/.test(id)) throw new Error("job id is invalid");
-  await getDb().execute({
-    sql: "INSERT INTO jobs (id, user_id, query, options, callback_url) VALUES (?, ?, ?, ?, ?)",
-    args: [id, userId, query, JSON.stringify(options), callbackUrl ?? null]
-  });
-}
-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 getOrCreateRunningJob(id, userId, query, options) {
-  const inserted = await getDb().execute({
-    sql: `INSERT INTO jobs (id, user_id, query, options, status, started_at)
-          VALUES (?, ?, ?, ?, 'running', datetime('now'))
-          ON CONFLICT(id) DO NOTHING`,
-    args: [id, userId, query, JSON.stringify(options)]
-  });
-  const job = await getJob(id, userId);
-  if (!job) throw new Error(`getOrCreateRunningJob: row missing immediately after insert/lookup for ${id}`);
-  return { job, created: inserted.rowsAffected === 1 };
-}
-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 NOTHING
-    `,
-    args: [
-      randomUUID(),
-      input.jobId,
-      input.userId,
-      input.attemptNumber,
-      input.maxAttempts,
-      input.query,
-      input.location,
-      input.maxQuestions,
-      input.startedAt
-    ]
-  });
-}
-async function attachHarvestAttemptProviderSession(input) {
-  const result = await getDb().execute({
-    sql: `
-      UPDATE harvest_attempts SET
-        browser_provider = ?,
-        provider_session_id = ?,
-        provider_session_observed_at = COALESCE(provider_session_observed_at, ?),
-        provider_lookup_status = CASE
-          WHEN provider_lookup_status = 'complete' THEN provider_lookup_status
-          ELSE 'pending'
-        END
-      WHERE job_id = ? AND attempt_number = ? AND status = 'running'
-    `,
-    args: [
-      input.browserProvider,
-      input.providerSessionId,
-      input.observedAt,
-      input.jobId,
-      input.attemptNumber
-    ]
-  });
-  return result.rowsAffected === 1;
-}
-async function finalizeExpiredHarvestAttempts(jobId, willRetry, completedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  const result = await getDb().execute({
-    sql: `
-      UPDATE harvest_attempts SET
-        status = 'finished',
-        outcome = COALESCE(outcome, 'timeout'),
-        question_count = COALESCE(question_count, 0),
-        duration_ms = COALESCE(duration_ms, MAX(0, CAST((julianday(?) - julianday(created_at)) * 86400000 AS INTEGER))),
-        error = COALESCE(error, 'Durable worker lease expired before attempt completion'),
-        will_retry = ?,
-        provider_error_code = COALESCE(provider_error_code, 'timeout'),
-        provider_error_message = COALESCE(provider_error_message, 'Durable worker lease expired before attempt completion'),
-        provider_reason_source = COALESCE(provider_reason_source, 'client_runtime'),
-        completed_at = COALESCE(completed_at, ?)
-      WHERE job_id = ? AND status = 'running'
-    `,
-    args: [completedAt, willRetry ? 1 : 0, completedAt, jobId]
-  });
-  return result.rowsAffected;
-}
-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 = ?,
-        browser_provider = COALESCE(browser_provider, ?),
-        provider_session_id = COALESCE(provider_session_id, ?),
-        provider_lookup_status = CASE
-          WHEN provider_lookup_status = 'complete' THEN provider_lookup_status
-          ELSE COALESCE(?, provider_lookup_status)
-        END,
-        provider_status = COALESCE(provider_status, ?),
-        provider_error_code = CASE
-          WHEN provider_reason_source = 'provider_session_api' THEN provider_error_code
-          ELSE COALESCE(?, provider_error_code)
-        END,
-        provider_error_message = CASE
-          WHEN provider_reason_source = 'provider_session_api' THEN provider_error_message
-          ELSE COALESCE(?, provider_error_message)
-        END,
-        provider_reason_source = CASE
-          WHEN provider_reason_source = 'provider_session_api' THEN provider_reason_source
-          ELSE COALESCE(?, provider_reason_source)
-        END,
-        provider_duration_ms = COALESCE(provider_duration_ms, ?),
-        provider_bandwidth_bytes = COALESCE(provider_bandwidth_bytes, ?),
-        provider_captcha = COALESCE(provider_captcha, ?),
-        provider_checked_at = COALESCE(provider_checked_at, ?),
-        provider_detail_json = COALESCE(provider_detail_json, ?),
-        provider_disconnect_observed = COALESCE(provider_disconnect_observed, ?),
-        provider_disconnect_message = COALESCE(provider_disconnect_message, ?),
-        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.browserProvider ?? null,
-      input.providerSessionId ?? null,
-      input.providerLookupStatus ?? null,
-      input.providerStatus ?? null,
-      input.providerErrorCode ?? null,
-      input.providerErrorMessage ?? null,
-      input.providerReasonSource ?? null,
-      input.providerDurationMs ?? null,
-      input.providerBandwidthBytes ?? null,
-      input.providerCaptcha == null ? null : input.providerCaptcha ? 1 : 0,
-      input.providerCheckedAt ?? null,
-      input.providerDetail == null ? null : boundedJson(input.providerDetail),
-      input.providerDisconnectObserved == null ? null : input.providerDisconnectObserved ? 1 : 0,
-      input.providerDisconnectMessage ?? null,
-      input.debug == null ? null : JSON.stringify(input.debug),
-      input.completedAt,
-      input.jobId,
-      input.attemptNumber
-    ]
-  });
-}
-function boundedJson(value, maxBytes = 4096) {
-  const serialized = JSON.stringify(value);
-  return serialized.length <= maxBytes ? serialized : JSON.stringify({ truncated: true });
-}
-async function updateHarvestAttemptProviderTelemetry(input) {
-  const result = await getDb().execute({
-    sql: `
-      UPDATE harvest_attempts SET
-        provider_lookup_status = ?,
-        provider_status = ?,
-        provider_error_code = ?,
-        provider_error_message = ?,
-        provider_reason_source = ?,
-        provider_duration_ms = ?,
-        provider_bandwidth_bytes = ?,
-        provider_captcha = ?,
-        provider_checked_at = ?,
-        provider_detail_json = ?
-      WHERE id = ?
-        AND job_id = ?
-        AND user_id = ?
-        AND browser_provider = 'bright_data_browser_api'
-        AND provider_session_id = ?
-        AND COALESCE(provider_lookup_status, '') <> 'complete'
-    `,
-    args: [
-      input.lookupStatus,
-      input.providerStatus ?? null,
-      input.errorCode ?? null,
-      input.errorMessage ?? null,
-      input.reasonSource ?? null,
-      input.durationMs ?? null,
-      input.bandwidthBytes ?? null,
-      input.captcha == null ? null : input.captcha ? 1 : 0,
-      input.checkedAt,
-      input.detail == null ? null : boundedJson(input.detail),
-      input.attemptId,
-      input.jobId,
-      input.userId,
-      input.providerSessionId
-    ]
-  });
-  return result.rowsAffected === 1;
-}
-async function listHarvestAttemptsPendingProviderTelemetry(limit = 25) {
-  const boundedLimit = Math.max(1, Math.min(100, Math.trunc(limit)));
-  const result = await getDb().execute({
-    sql: `
-      SELECT * FROM harvest_attempts
-      WHERE browser_provider = 'bright_data_browser_api'
-        AND provider_session_id IS NOT NULL
-        AND provider_lookup_status IN ('pending', 'temporary_error')
-      ORDER BY COALESCE(provider_checked_at, created_at) ASC
-      LIMIT ?
-    `,
-    args: [boundedLimit]
-  });
-  return result.rows.map((row) => rowToHarvestAttemptLog(row));
-}
-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'
-      AND COALESCE(json_extract(options, '$.executionOwner'), 'cron') NOT IN ('direct', 'inngest')
-    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" };
-}
-var DURABLE_PAA_LEASE_MS = 45e3;
-async function claimDurablePaaJob(id) {
-  const db = getDb();
-  const current = await getJob(id);
-  if (!current || current.options.executionOwner !== "direct" || current.options.serpOnly === true) return void 0;
-  const recoveryCount = Math.max(0, Number(current.options.paaRecoveryCount ?? 0));
-  if (current.status === "running") return void 0;
-  if (current.status === "pending") {
-    const leaseToken = randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const leaseExpiresAt = new Date(Date.now() + DURABLE_PAA_LEASE_MS).toISOString();
-    const updated = await db.execute({
-      sql: `UPDATE jobs
-            SET status = 'running', started_at = datetime('now'), error = NULL,
-                options = json_set(options,
-                  '$.paaLeaseToken', ?,
-                  '$.paaLeaseExpiresAt', ?,
-                  '$.paaLastDispatchAt', ?)
-            WHERE id = ? AND status = 'pending'`,
-      args: [leaseToken, leaseExpiresAt, now, id]
-    });
-    if (updated.rowsAffected === 0) return void 0;
-    return {
-      job: {
-        ...current,
-        status: "running",
-        started_at: now,
-        options: { ...current.options, paaLeaseToken: leaseToken, paaLeaseExpiresAt: leaseExpiresAt, paaLastDispatchAt: now }
-      },
-      leaseToken,
-      recoveryCount
-    };
-  }
-  return { job: current, leaseToken: null, recoveryCount };
-}
-async function checkpointJob(id, result) {
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET result = ? WHERE id = ? AND status = 'running'`,
-    args: [JSON.stringify(result), id]
-  });
-  return updated.rowsAffected === 1;
-}
-async function checkpointDurablePaaJob(id, leaseToken, result) {
-  const leaseExpiresAt = new Date(Date.now() + DURABLE_PAA_LEASE_MS).toISOString();
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET result = ?, options = json_set(options, '$.paaLeaseExpiresAt', ?)
-          WHERE id = ? AND status = 'running' AND json_extract(options, '$.paaLeaseToken') = ?`,
-    args: [JSON.stringify(result), leaseExpiresAt, id, leaseToken]
-  });
-  return updated.rowsAffected === 1;
-}
-async function renewDurablePaaLease(id, leaseToken) {
-  const leaseExpiresAt = new Date(Date.now() + DURABLE_PAA_LEASE_MS).toISOString();
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET options = json_set(options, '$.paaLeaseExpiresAt', ?)
-          WHERE id = ? AND status = 'running' AND json_extract(options, '$.paaLeaseToken') = ?`,
-    args: [leaseExpiresAt, id, leaseToken]
-  });
-  return updated.rowsAffected === 1;
-}
-async function completeDurablePaaJob(id, leaseToken, result) {
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET status = 'done', result = ?, error = NULL, public_error_json = NULL,
-            completed_at = datetime('now'),
-            options = json_set(options, '$.paaLeaseExpiresAt', NULL)
-          WHERE id = ? AND status = 'running' AND json_extract(options, '$.paaLeaseToken') = ?`,
-    args: [JSON.stringify(result), id, leaseToken]
-  });
-  return updated.rowsAffected === 1;
-}
-async function failDurablePaaJob(id, leaseToken, error, publicError) {
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET status = 'failed', error = ?, public_error_json = ?, completed_at = datetime('now'),
-            options = json_set(options, '$.paaLeaseExpiresAt', NULL)
-          WHERE id = ? AND status = 'running' AND json_extract(options, '$.paaLeaseToken') = ?`,
-    args: [error, serializePublicErrorEnvelope(publicError), id, leaseToken]
-  });
-  return updated.rowsAffected === 1;
-}
-async function requeueExpiredDurablePaaJob(id, maxRecoveries) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET status = 'pending', started_at = NULL,
-            result = CASE WHEN json_valid(result) THEN json_set(result,
-              '$.progress.lifecycle.discoveryStatus', 'interrupted',
-              '$.progress.lifecycle.completionReason', 'The previous worker lease expired; the same job is recovering automatically.',
-              '$.progress.lifecycle.automaticRetries', COALESCE(json_extract(options, '$.paaRecoveryCount'), 0) + 1)
-              ELSE result END,
-            options = json_set(options,
-              '$.paaRecoveryCount', COALESCE(json_extract(options, '$.paaRecoveryCount'), 0) + 1,
-              '$.paaLeaseToken', NULL,
-              '$.paaLeaseExpiresAt', NULL,
-              '$.paaRecoveryQueuedAt', ?)
-          WHERE id = ? AND status = 'running'
-            AND (
-              datetime(json_extract(options, '$.paaLeaseExpiresAt')) <= datetime('now')
-              OR (json_extract(options, '$.paaLeaseExpiresAt') IS NULL AND started_at <= datetime('now', '-15 minutes'))
-            )
-            AND COALESCE(json_extract(options, '$.paaRecoveryCount'), 0) < ?`,
-    args: [now, id, Math.max(0, Math.trunc(maxRecoveries))]
-  });
-  return updated.rowsAffected === 1;
-}
-async function completeExpiredDurablePaaJob(id, result) {
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET status = 'done', result = ?, error = NULL, public_error_json = NULL, completed_at = datetime('now')
-          WHERE id = ? AND status = 'running'
-            AND (
-              datetime(json_extract(options, '$.paaLeaseExpiresAt')) <= datetime('now')
-              OR (json_extract(options, '$.paaLeaseExpiresAt') IS NULL AND started_at <= datetime('now', '-15 minutes'))
-            )`,
-    args: [JSON.stringify(result), id]
-  });
-  return updated.rowsAffected === 1;
-}
-async function failExpiredDurablePaaJob(id, error, publicError) {
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET status = 'failed', error = ?, public_error_json = ?, completed_at = datetime('now')
-          WHERE id = ? AND status = 'running'
-            AND (
-              datetime(json_extract(options, '$.paaLeaseExpiresAt')) <= datetime('now')
-              OR (json_extract(options, '$.paaLeaseExpiresAt') IS NULL AND started_at <= datetime('now', '-15 minutes'))
-            )`,
-    args: [error, serializePublicErrorEnvelope(publicError), id]
-  });
-  return updated.rowsAffected === 1;
-}
-async function listRecentTerminalDurablePaaJobs(limit = 25) {
-  const safeLimit = Math.max(1, Math.min(100, Math.floor(limit)));
-  const rows = await getDb().execute({
-    sql: `SELECT * FROM jobs
-          WHERE status IN ('done', 'failed', 'cancelled')
-            AND json_extract(options, '$.executionOwner') IN ('direct', 'inngest')
-            AND json_extract(options, '$.billingDebitKey') IS NOT NULL
-            AND json_extract(options, '$.billingSettledAt') IS NULL
-          ORDER BY completed_at DESC
-          LIMIT ?`,
-    args: [safeLimit]
-  });
-  return rows.rows.map((row) => deserialize(rowToRawJob(row)));
-}
-async function listStaleRunningDurablePaaJobs(limit = 25) {
-  const safeLimit = Math.max(1, Math.min(100, Math.floor(limit)));
-  const rows = await getDb().execute({
-    sql: `SELECT * FROM jobs
-          WHERE status = 'running'
-            AND started_at <= datetime('now', '-15 minutes')
-            AND json_extract(options, '$.executionOwner') IN ('direct', 'inngest')
-          ORDER BY started_at
-          LIMIT ?`,
-    args: [safeLimit]
-  });
-  return rows.rows.map((row) => deserialize(rowToRawJob(row)));
-}
-async function listRecoverableDurablePaaJobs(limit = 25) {
-  const safeLimit = Math.max(1, Math.min(100, Math.floor(limit)));
-  const rows = await getDb().execute({
-    sql: `SELECT * FROM jobs
-          WHERE json_extract(options, '$.executionOwner') = 'direct'
-            AND json_extract(options, '$.serpOnly') IS NOT 1
-            AND (
-              (status = 'running' AND (
-                datetime(json_extract(options, '$.paaLeaseExpiresAt')) <= datetime('now')
-                OR (json_extract(options, '$.paaLeaseExpiresAt') IS NULL AND started_at <= datetime('now', '-15 minutes'))
-              ))
-              OR
-              (status = 'pending' AND COALESCE(json_extract(options, '$.paaRecoveryCount'), 0) > 0
-                AND datetime(COALESCE(json_extract(options, '$.paaLastDispatchAt'), '1970-01-01')) <= datetime('now', '-30 seconds'))
-            )
-          ORDER BY COALESCE(started_at, created_at)
-          LIMIT ?`,
-    args: [safeLimit]
-  });
-  return rows.rows.map((row) => deserialize(rowToRawJob(row)));
-}
-async function markJobBillingSettled(id, billedMc, settledAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!Number.isSafeInteger(billedMc) || billedMc < 0) throw new Error("job billed amount must be a non-negative integer");
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs
-          SET options = json_set(options, '$.billingSettledAt', ?, '$.billedMc', ?)
-          WHERE id = ?`,
-    args: [settledAt, billedMc, id]
-  });
-  return updated.rowsAffected === 1;
-}
-async function completeJob(id, result) {
-  await getDb().execute({
-    sql: `UPDATE jobs SET status = 'done', result = ?, error = NULL, public_error_json = NULL, completed_at = datetime('now') WHERE id = ?`,
-    args: [JSON.stringify(result), id]
-  });
-}
-async function completeRunningJob(id, result) {
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET status = 'done', result = ?, error = NULL, public_error_json = NULL, completed_at = datetime('now')
-          WHERE id = ? AND status = 'running'`,
-    args: [JSON.stringify(result), id]
-  });
-  return updated.rowsAffected === 1;
-}
-async function failJob(id, error, publicError) {
-  await getDb().execute({
-    sql: `UPDATE jobs SET status = 'failed', error = ?, public_error_json = ?, completed_at = datetime('now') WHERE id = ?`,
-    args: [error, serializePublicErrorEnvelope(publicError), id]
-  });
-}
-async function failRunningJob(id, error, publicError) {
-  const updated = await getDb().execute({
-    sql: `UPDATE jobs SET status = 'failed', error = ?, public_error_json = ?, completed_at = datetime('now')
-          WHERE id = ? AND status = 'running'`,
-    args: [error, serializePublicErrorEnvelope(publicError), id]
-  });
-  return updated.rowsAffected === 1;
-}
-async function cancelJob(id, reason, publicError) {
-  await getDb().execute({
-    sql: `UPDATE jobs SET status = 'cancelled', error = ?, public_error_json = ?, completed_at = datetime('now') WHERE id = ?`,
-    args: [reason, serializePublicErrorEnvelope(publicError), 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) {
-  if (!Number.isSafeInteger(slots) || slots < 0) {
-    throw new Error("extra concurrency slots must be a non-negative safe integer");
-  }
-  await setConcurrencyPackQuantity(userId, Math.ceil(slots / 2));
-}
-async function setConcurrencyPackQuantity(userId, quantity) {
-  if (!Number.isSafeInteger(quantity) || quantity < 0) {
-    throw new Error("concurrency pack quantity must be a non-negative safe integer");
-  }
-  await getDb().execute({
-    sql: "UPDATE users SET concurrency_pack_quantity = ?, extra_concurrency_slots = ? WHERE id = ?",
-    args: [quantity, quantity * 2, 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 {
-  RECAPTCHA_INSTRUCTIONS,
-  PUBLIC_SERVICE_UNAVAILABLE_MESSAGE,
-  PUBLIC_ERROR_CODES,
-  serializePublicErrorEnvelope,
-  parsePublicErrorEnvelope,
-  normalizePublicErrorCode,
-  publicErrorMessage,
-  buildPublicErrorEnvelope,
-  sanitizeVendorName,
-  CaptchaError,
-  ExtractionError,
-  MapsSearchIncompletePageError,
-  RequestAbortedError,
-  PaaInteractionInterruptedError,
-  LocationMismatchError,
-  CREDIT_LOTS_EPOCH,
-  CORE_SCHEMA_VERSION,
-  SITE_EXTRACT_COUNTER_REPAIR_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,
-  createJobWithId,
-  createRunningJob,
-  getOrCreateRunningJob,
-  startHarvestAttempt,
-  attachHarvestAttemptProviderSession,
-  finalizeExpiredHarvestAttempts,
-  finishHarvestAttempt,
-  updateHarvestAttemptProviderTelemetry,
-  listHarvestAttemptsPendingProviderTelemetry,
-  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,
-  claimDurablePaaJob,
-  checkpointJob,
-  checkpointDurablePaaJob,
-  renewDurablePaaLease,
-  completeDurablePaaJob,
-  failDurablePaaJob,
-  requeueExpiredDurablePaaJob,
-  completeExpiredDurablePaaJob,
-  failExpiredDurablePaaJob,
-  listRecentTerminalDurablePaaJobs,
-  listStaleRunningDurablePaaJobs,
-  listRecoverableDurablePaaJobs,
-  markJobBillingSettled,
-  completeJob,
-  completeRunningJob,
-  failJob,
-  failRunningJob,
-  cancelJob,
-  createKpoJob,
-  claimPendingKpoJob,
-  getKpoJob,
-  updateKpoJobState,
-  completeKpoJob,
-  failKpoJob,
-  logKpoPhaseComplete,
-  getKpoPhaseLog,
-  listKpoJobs,
-  getUserByStripeCustomerId,
-  setStripeCustomerId,
-  setExtraConcurrencySlots,
-  setConcurrencyPackQuantity,
-  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
-};