@xylex-group/athena 3.1.0 → 3.5.1

package/dist/index.cjs

@@ -1844,6 +1844,8 @@ function buildUpdateDebugSql(payload) {
     sqlParts.push(`WHERE ${whereClauses.join(" AND ")}`);
   }
   const pagination = resolvePagination({
+    limit: payload.limit,
+    offset: payload.offset,
     currentPage: payload.current_page,
     pageSize: payload.page_size
   });
@@ -1866,6 +1868,8 @@ function buildDeleteDebugSql(payload) {
     sqlParts.push(`WHERE ${whereClauses.join(" AND ")}`);
   }
   const pagination = resolvePagination({
+    limit: payload.limit,
+    offset: payload.offset,
     currentPage: payload.current_page,
     pageSize: payload.page_size
   });
@@ -2009,7 +2013,7 @@ function buildAthenaGatewayUrl(baseUrl, path) {
 
 // package.json
 var package_default = {
-  version: "3.1.0"
+  version: "3.5.1"
 };
 
 // src/sdk-version.ts
@@ -2306,13 +2310,14 @@ var LEGACY_COOKIE_PREFIX = "better-auth";
 var DEFAULT_SESSION_MAX_AGE = 7 * 24 * 60 * 60;
 var DEFAULT_CACHE_MAX_AGE = 60 * 5;
 function isProductionRuntime() {
-  return typeof process !== "undefined" && process.env?.NODE_ENV === "production";
+  return globalThis.process?.env?.NODE_ENV === "production";
 }
 function getEnvironmentSecret() {
-  if (typeof process === "undefined") {
+  const env = globalThis.process?.env;
+  if (!env) {
     return void 0;
   }
-  return process.env?.ATHENA_AUTH_SECRET || process.env?.BETTER_AUTH_SECRET || process.env?.AUTH_SECRET;
+  return env.ATHENA_AUTH_SECRET || env.BETTER_AUTH_SECRET || env.AUTH_SECRET;
 }
 function isDynamicBaseURLConfig(baseURL) {
   return typeof baseURL === "object" && baseURL !== null && "allowedHosts" in baseURL && Array.isArray(baseURL.allowedHosts);
@@ -4769,6 +4774,14 @@ function createAuthModule(config = {}, runtimeOptions = {}) {
     changeEmailVerify: (input, options) => getWithQuery("/change-email/verify", input, options),
     deleteUserVerify: (input, options) => getWithQuery("/delete-user/verify", input, options),
     changePassword: (input, options) => postGeneric("/change-password", input, options),
+    // Better Auth UI flat method aliases (also nested under session/account/social/user).
+    listSessions: (input, options) => getGeneric("/list-sessions", input, options),
+    revokeSession: sessionRevokeBinding,
+    revokeOtherSessions,
+    listAccounts: (input, options) => getGeneric("/list-accounts", input, options),
+    unlinkAccount: (input, options) => postGeneric("/unlink-account", input, options),
+    linkSocial: (input, options) => postGeneric("/link-social", input, options),
+    updateUser: (input, options) => postGeneric("/update-user", input, options),
     user: {
       update: (input, options) => postGeneric("/update-user", input, options),
       delete: (input, options) => postGeneric("/delete-user", input, options),
@@ -5874,9 +5887,9 @@ function readHeadersField(value) {
   const headers = value.headers;
   if (!isRecord8(headers)) return {};
   const result = {};
-  for (const [key, headerValue2] of Object.entries(headers)) {
-    if (typeof headerValue2 === "string") {
-      result[key] = headerValue2;
+  for (const [key, headerValue3] of Object.entries(headers)) {
+    if (typeof headerValue3 === "string") {
+      result[key] = headerValue3;
     }
   }
   return result;
@@ -9554,6 +9567,8 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, beha
           strip_nulls: mergedOptions?.stripNulls ?? true
         };
         if (executionState.order) payload.sort_by = executionState.order;
+        if (executionState.limit !== void 0) payload.limit = executionState.limit;
+        if (executionState.offset !== void 0) payload.offset = executionState.offset;
         if (executionState.currentPage !== void 0) payload.current_page = executionState.currentPage;
         if (executionState.pageSize !== void 0) payload.page_size = executionState.pageSize;
         if (executionState.totalPages !== void 0) payload.total_pages = executionState.totalPages;
@@ -9608,6 +9623,8 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, beha
           conditions: filters
         };
         if (executionState.order) payload.sort_by = executionState.order;
+        if (executionState.limit !== void 0) payload.limit = executionState.limit;
+        if (executionState.offset !== void 0) payload.offset = executionState.offset;
         if (executionState.currentPage !== void 0) payload.current_page = executionState.currentPage;
         if (executionState.pageSize !== void 0) payload.page_size = executionState.pageSize;
         if (executionState.totalPages !== void 0) payload.total_pages = executionState.totalPages;
@@ -9659,7 +9676,11 @@ function createQueryBuilder(client, formatGatewayResult, behavior, tracer) {
     if (!normalizedQuery) {
       throw new Error("query requires a non-empty string");
     }
-    const payload = { query: normalizedQuery };
+    const params = options?.params;
+    const payload = {
+      query: normalizedQuery,
+      ...Array.isArray(params) ? { params } : {}
+    };
     const callsite = captureTraceCallsite(tracer);
     return executeRead(
       behavior,
@@ -9708,7 +9729,7 @@ function normalizeAuthClientConfig(auth, defaultBaseUrl) {
 }
 function createInternalClientCore(config) {
   const normalizedAuthConfig = normalizeAuthClientConfig(config.auth, config.authUrl);
-  const gatewayTransport = createAthenaGatewayClient({
+  const gatewayTransport = config.gatewayTransport ?? createAthenaGatewayClient({
     baseUrl: config.baseUrl,
     apiKey: config.apiKey,
     client: config.client ?? void 0,
@@ -9863,205 +9884,2843 @@ function createInternalClientView(core, resolveContext) {
   };
 }
 
-// src/billing/module.ts
-var SDK_NAME5 = "xylex-group/athena-billing";
-var SDK_HEADER_VALUE4 = buildSdkHeaderValue(SDK_NAME5);
-var AthenaBillingError = class extends Error {
-  status;
-  endpoint;
-  method;
-  body;
-  constructor(input) {
-    super(input.message);
-    this.name = "AthenaBillingError";
-    this.status = input.status;
-    this.endpoint = input.endpoint;
-    this.method = input.method;
-    this.body = input.body;
-  }
-};
-var billingSdkManifest = {
-  namespace: "billing",
-  envelopeKind: "athena",
-  methods: [
-    { name: "getCapabilities", method: "GET", path: "/billing/v1/capabilities" },
-    { name: "createCheckout", method: "POST", path: "/billing/v1/checkouts" },
-    { name: "listProducts", method: "GET", path: "/billing/v1/products" },
-    { name: "listPrices", method: "GET", path: "/billing/v1/prices" },
-    { name: "listCustomers", method: "GET", path: "/billing/v1/customers" },
-    { name: "createCustomer", method: "POST", path: "/billing/v1/customers" },
-    { name: "getCustomer", method: "GET", path: "/billing/v1/customers/{id}" },
-    { name: "updateCustomer", method: "PATCH", path: "/billing/v1/customers/{id}" },
-    { name: "deleteCustomer", method: "DELETE", path: "/billing/v1/customers/{id}" },
-    { name: "listPayments", method: "GET", path: "/billing/v1/payments" },
-    { name: "createPayment", method: "POST", path: "/billing/v1/payments" },
-    { name: "getPayment", method: "GET", path: "/billing/v1/payments/{id}" },
-    { name: "cancelPayment", method: "POST", path: "/billing/v1/payments/{id}/cancel" },
-    { name: "listPaymentLinks", method: "GET", path: "/billing/v1/payment-links" },
-    { name: "createPaymentLink", method: "POST", path: "/billing/v1/payment-links" },
-    { name: "getPaymentLink", method: "GET", path: "/billing/v1/payment-links/{id}" },
-    { name: "updatePaymentLink", method: "PATCH", path: "/billing/v1/payment-links/{id}" },
-    { name: "deletePaymentLink", method: "DELETE", path: "/billing/v1/payment-links/{id}" },
-    { name: "listRefunds", method: "GET", path: "/billing/v1/refunds" },
-    { name: "createRefund", method: "POST", path: "/billing/v1/refunds" },
-    { name: "getRefund", method: "GET", path: "/billing/v1/refunds/{id}" },
-    { name: "cancelRefund", method: "POST", path: "/billing/v1/refunds/{id}/cancel" },
-    { name: "listSubscriptions", method: "GET", path: "/billing/v1/subscriptions" },
-    { name: "createSubscription", method: "POST", path: "/billing/v1/subscriptions" },
-    { name: "getSubscription", method: "GET", path: "/billing/v1/subscriptions/{id}" },
-    { name: "updateSubscription", method: "PATCH", path: "/billing/v1/subscriptions/{id}" },
-    { name: "cancelSubscription", method: "POST", path: "/billing/v1/subscriptions/{id}/cancel" },
-    { name: "listInvoices", method: "GET", path: "/billing/v1/invoices" },
-    { name: "getInvoice", method: "GET", path: "/billing/v1/invoices/{id}" },
-    { name: "listWebhooks", method: "GET", path: "/billing/v1/webhooks" },
-    { name: "createWebhook", method: "POST", path: "/billing/v1/webhooks" },
-    { name: "getWebhook", method: "GET", path: "/billing/v1/webhooks/{id}" },
-    { name: "updateWebhook", method: "PATCH", path: "/billing/v1/webhooks/{id}" },
-    { name: "deleteWebhook", method: "DELETE", path: "/billing/v1/webhooks/{id}" },
-    { name: "testWebhook", method: "POST", path: "/billing/v1/webhooks/{id}/test" },
-    {
-      name: "listConnections",
-      method: "GET",
-      path: "/admin/billing/clients/{client_name}/connections"
-    },
-    {
-      name: "createConnection",
-      method: "POST",
-      path: "/admin/billing/clients/{client_name}/connections"
-    },
-    {
-      name: "getConnection",
-      method: "GET",
-      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
-    },
-    {
-      name: "updateConnection",
-      method: "PATCH",
-      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
-    },
-    {
-      name: "deleteConnection",
-      method: "DELETE",
-      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
-    },
-    {
-      name: "reconcileDocument",
-      method: "POST",
-      path: "/admin/billing/clients/{client_name}/connections/{connection_id}/reconcile"
-    },
-    {
-      name: "listWebhookEvents",
-      method: "GET",
-      path: "/admin/billing/clients/{client_name}/webhook-events"
+// src/cloudflare/types.ts
+var CLOUDFLARE_EDGE_BASE_URL = "https://athena.local/cloudflare-edge";
+var CLOUDFLARE_EDGE_API_KEY = "cloudflare-edge-local";
+
+// src/cloudflare/capabilities.ts
+function createGatewayCapabilities(options) {
+  const storageConfigured = options?.storageConfigured ?? true;
+  return {
+    mode: "gateway",
+    db: {
+      engine: options?.engine ?? "postgresql",
+      local: false,
+      layers: {
+        query: true,
+        flatCrud: true,
+        findManyAst: true,
+        rpc: true,
+        relations: true
+      }
     },
-    {
-      name: "provisionWebhookSinks",
-      method: "POST",
-      path: "/admin/billing/clients/{client_name}/webhook-sinks/provision"
+    storage: {
+      local: false,
+      objects: storageConfigured,
+      catalogs: storageConfigured ? options?.storageCatalogs ?? true : false,
+      backups: storageConfigured ? options?.storageBackups ?? true : false
     },
-    { name: "listGrants", method: "GET", path: "/admin/billing/grants" },
-    { name: "listProviders", method: "GET", path: "/admin/billing/providers" },
-    {
-      name: "listSinkHelpers",
-      method: "GET",
-      path: "/admin/webhook-sinks/helpers/billing"
+    auth: {
+      remote: options?.authRemote ?? true
+    }
+  };
+}
+function createCloudflareEdgeCapabilities(options) {
+  const hasObjects = options.hasR2 || Boolean(options.hasRemoteStorage);
+  return {
+    mode: "cloudflare-edge",
+    db: {
+      engine: "cloudflare-d1",
+      local: true,
+      layers: {
+        query: true,
+        flatCrud: true,
+        findManyAst: options.findManyAst ?? false,
+        rpc: false,
+        relations: false
+      }
     },
-    {
-      name: "ingestProviderWebhook",
-      method: "POST",
-      path: "/billing/providers/{provider}/clients/{client_name}/connections/{connection_id}/webhook"
+    storage: {
+      // Local objects only when an R2 binding is present.
+      local: options.hasR2,
+      // Remote hybrid root can still expose storage.objects via the HTTP API.
+      objects: hasObjects,
+      catalogs: false,
+      backups: false
     },
-    { name: "getDebugBilling", method: "GET", path: "/debug/billing" }
-  ]
-};
-function withPathParam2(path, name, value) {
-  return path.replace(`{${name}}`, encodeURIComponent(value));
+    auth: {
+      remote: options.authRemote
+    }
+  };
 }
-function appendQuery3(path, query) {
-  if (!query) return path;
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(query)) {
-    if (value === void 0 || value === null) continue;
-    params.set(key, String(value));
-  }
-  const serialized = params.toString();
-  return serialized ? `${path}?${serialized}` : path;
+
+// src/cloudflare/d1/runner.ts
+function resultColumns(rows) {
+  const first = rows.find((value) => value && typeof value === "object" && !Array.isArray(value));
+  if (!first) return [];
+  return Object.keys(first);
 }
-function connectionQuery(input) {
-  const query = {
-    connectionId: input.connectionId
-  };
-  if (input.clientName) query.clientName = input.clientName;
-  if ("cursor" in input && input.cursor) query.cursor = input.cursor;
-  if ("source" in input && input.source) query.source = input.source;
-  if ("limit" in input && input.limit !== void 0) query.limit = String(input.limit);
-  if ("offset" in input && input.offset !== void 0) query.offset = String(input.offset);
-  return query;
+function isIdentChar(ch) {
+  if (!ch) return false;
+  return /[A-Za-z0-9_]/.test(ch);
 }
-function parseEnvelopeData(body) {
-  if (body && typeof body === "object" && "data" in body) {
-    return body.data;
+function scanSqlKeywordsOutsideLiterals(sql, onKeyword) {
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inBracket = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i += 1) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      if (ch === "\n" || ch === "\r") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        i += 1;
+        inBlockComment = false;
+      }
+      continue;
+    }
+    if (inSingle) {
+      if (ch === "'" && next === "'") {
+        i += 1;
+        continue;
+      }
+      if (ch === "'") inSingle = false;
+      continue;
+    }
+    if (inDouble) {
+      if (ch === '"' && next === '"') {
+        i += 1;
+        continue;
+      }
+      if (ch === '"') inDouble = false;
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`" && next === "`") {
+        i += 1;
+        continue;
+      }
+      if (ch === "`") inBacktick = false;
+      continue;
+    }
+    if (inBracket) {
+      if (ch === "]") inBracket = false;
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      continue;
+    }
+    if (ch === "[") {
+      inBracket = true;
+      continue;
+    }
+    if (!isIdentChar(ch) || isIdentChar(sql[i - 1])) {
+      continue;
+    }
+    let end = i + 1;
+    while (end < sql.length && isIdentChar(sql[end])) {
+      end += 1;
+    }
+    const keyword = sql.slice(i, end);
+    if (onKeyword(keyword, i)) {
+      return;
+    }
+    i = end - 1;
   }
-  return body;
 }
-function createBillingModule(config) {
-  const baseUrl = normalizeAthenaGatewayBaseUrl(config.baseUrl, {
-    label: "Athena billing base URL"
+function sqlContainsKeywordOutsideLiterals(sql, keyword) {
+  const target = keyword.toUpperCase();
+  let found = false;
+  scanSqlKeywordsOutsideLiterals(sql, (token) => {
+    if (token.toUpperCase() === target) {
+      found = true;
+      return true;
+    }
+    return false;
   });
-  const fetchImpl = config.fetchImpl ?? globalThis.fetch.bind(globalThis);
-  async function call(method, path, body, options, responseType = "json") {
-    const headers = buildAthenaRequestHeaders({
-      profile: "gateway",
-      sdkHeaderValue: SDK_HEADER_VALUE4,
-      apiKey: options?.apiKey ?? config.apiKey,
-      client: config.client,
-      configHeaders: {
-        ...config.headers ?? {}
-      },
-      callHeaders: options?.headers,
-      contentType: "application/json"
-    });
-    let requestBody;
-    if (body !== void 0 && body !== null) {
-      if (typeof body === "string" || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof FormData || body instanceof URLSearchParams) {
-        requestBody = body;
-      } else {
-        requestBody = JSON.stringify(body);
-        if (!hasHeaderIgnoreCase(headers, "Content-Type")) {
-          headers["Content-Type"] = "application/json";
-        }
+  return found;
+}
+function sqlFirstKeywordOutsideLiterals(sql) {
+  let first = null;
+  scanSqlKeywordsOutsideLiterals(sql, (token) => {
+    first = token;
+    return true;
+  });
+  return first;
+}
+var ROW_PRODUCING_LEAD_KEYWORDS = /* @__PURE__ */ new Set(["SELECT", "PRAGMA", "EXPLAIN", "VALUES"]);
+var MUTATION_LEAD_KEYWORDS = /* @__PURE__ */ new Set(["INSERT", "UPDATE", "DELETE", "REPLACE"]);
+var WITH_TERMINAL_KEYWORDS = /* @__PURE__ */ new Set([
+  "SELECT",
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "REPLACE",
+  "VALUES",
+  "PRAGMA",
+  "EXPLAIN"
+]);
+function sqlTerminalKeywordAfterWith(sql) {
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inBracket = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let depth = 0;
+  let sawWith = false;
+  for (let i = 0; i < sql.length; i += 1) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      if (ch === "\n" || ch === "\r") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        i += 1;
+        inBlockComment = false;
       }
+      continue;
     }
-    const targetUrl = `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
-    const response = await fetchImpl(targetUrl, {
-      method,
-      headers,
-      body: requestBody,
-      signal: options?.signal
-    });
-    if (responseType === "text") {
-      const text = await response.text();
-      if (!response.ok) {
-        throw new AthenaBillingError({
-          message: `Billing request failed (${response.status})`,
-          status: response.status,
-          endpoint: path,
-          method,
-          body: text
-        });
+    if (inSingle) {
+      if (ch === "'" && next === "'") {
+        i += 1;
+        continue;
       }
-      return text;
+      if (ch === "'") inSingle = false;
+      continue;
     }
-    const rawText = await response.text();
-    let parsed = rawText;
-    if (rawText) {
-      try {
-        parsed = JSON.parse(rawText);
-      } catch {
-        parsed = rawText;
+    if (inDouble) {
+      if (ch === '"' && next === '"') {
+        i += 1;
+        continue;
       }
-    } else {
-      parsed = null;
+      if (ch === '"') inDouble = false;
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`" && next === "`") {
+        i += 1;
+        continue;
+      }
+      if (ch === "`") inBacktick = false;
+      continue;
+    }
+    if (inBracket) {
+      if (ch === "]") inBracket = false;
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      continue;
+    }
+    if (ch === "[") {
+      inBracket = true;
+      continue;
+    }
+    if (ch === "(") {
+      depth += 1;
+      continue;
+    }
+    if (ch === ")") {
+      if (depth > 0) depth -= 1;
+      continue;
+    }
+    if (depth !== 0 || !isIdentChar(ch) || isIdentChar(sql[i - 1])) {
+      continue;
+    }
+    let end = i + 1;
+    while (end < sql.length && isIdentChar(sql[end])) {
+      end += 1;
+    }
+    const keyword = sql.slice(i, end);
+    const upper = keyword.toUpperCase();
+    if (!sawWith) {
+      if (upper === "WITH") {
+        sawWith = true;
+      }
+      i = end - 1;
+      continue;
+    }
+    if (WITH_TERMINAL_KEYWORDS.has(upper)) {
+      return keyword;
+    }
+    i = end - 1;
+  }
+  return null;
+}
+function sqlLeadStatementKeyword(sql) {
+  const first = sqlFirstKeywordOutsideLiterals(sql);
+  if (!first) return null;
+  if (first.toUpperCase() !== "WITH") return first;
+  return sqlTerminalKeywordAfterWith(sql) ?? first;
+}
+function statementExpectsResultRows(sql) {
+  const lead = sqlLeadStatementKeyword(sql);
+  if (lead) {
+    const upper = lead.toUpperCase();
+    if (ROW_PRODUCING_LEAD_KEYWORDS.has(upper)) {
+      return true;
+    }
+    if (MUTATION_LEAD_KEYWORDS.has(upper)) {
+      return sqlContainsKeywordOutsideLiterals(sql, "RETURNING");
+    }
+  }
+  return sqlContainsKeywordOutsideLiterals(sql, "RETURNING");
+}
+function collectRowsFromBatchResults(results) {
+  const rows = [];
+  for (const item of results) {
+    if (Array.isArray(item.results) && item.results.length > 0) {
+      rows.push(...item.results);
+    }
+  }
+  return rows;
+}
+function sumBatchAffectedRows(results, statementCount) {
+  let sum2 = 0;
+  let sawChanges = false;
+  for (const item of results) {
+    const changes = item.meta?.changes;
+    if (typeof changes === "number") {
+      sum2 += changes;
+      sawChanges = true;
+    }
+  }
+  return sawChanges ? sum2 : statementCount;
+}
+function matchSqlKeywordAt(query, index, keyword) {
+  const len = keyword.length;
+  if (index + len > query.length) {
+    return null;
+  }
+  const slice = query.slice(index, index + len);
+  if (slice.toLowerCase() !== keyword.toLowerCase()) {
+    return null;
+  }
+  const before = index === 0 ? "" : query[index - 1];
+  const after = index + len >= query.length ? "" : query[index + len];
+  const isIdent = (c) => /[A-Za-z0-9_]/.test(c);
+  if (before && isIdent(before)) {
+    return null;
+  }
+  if (after && isIdent(after)) {
+    return null;
+  }
+  return len;
+}
+function splitSqlStatements(query) {
+  const statements = [];
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inBracket = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let segmentStart = 0;
+  let segmentHasContent = false;
+  let awaitTriggerBegin = false;
+  let triggerBodyDepth = 0;
+  let caseDepth = 0;
+  const flushSegment = (end) => {
+    if (!segmentHasContent) {
+      segmentStart = end + 1;
+      return;
+    }
+    const sql = query.slice(segmentStart, end).trim();
+    if (sql) {
+      statements.push(sql);
+    }
+    segmentHasContent = false;
+    segmentStart = end + 1;
+    awaitTriggerBegin = false;
+    triggerBodyDepth = 0;
+    caseDepth = 0;
+  };
+  for (let i = 0; i < query.length; i += 1) {
+    const ch = query[i];
+    const next = query[i + 1];
+    if (inLineComment) {
+      if (ch === "\n" || ch === "\r") {
+        inLineComment = false;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inSingle) {
+      if (ch === "'" && next === "'") {
+        i += 1;
+        continue;
+      }
+      if (ch === "'") {
+        inSingle = false;
+      }
+      continue;
+    }
+    if (inDouble) {
+      if (ch === '"' && next === '"') {
+        i += 1;
+        continue;
+      }
+      if (ch === '"') {
+        inDouble = false;
+      }
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`" && next === "`") {
+        i += 1;
+        continue;
+      }
+      if (ch === "`") {
+        inBacktick = false;
+      }
+      continue;
+    }
+    if (inBracket) {
+      if (ch === "]") {
+        inBracket = false;
+      }
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      segmentHasContent = true;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      segmentHasContent = true;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      segmentHasContent = true;
+      continue;
+    }
+    if (ch === "[") {
+      inBracket = true;
+      segmentHasContent = true;
+      continue;
+    }
+    if (/[A-Za-z_]/.test(ch)) {
+      const createLen = matchSqlKeywordAt(query, i, "CREATE");
+      if (createLen != null) {
+        let j2 = i + createLen;
+        const skipWsAndComments = () => {
+          while (j2 < query.length) {
+            const c = query[j2];
+            const n = query[j2 + 1];
+            if (/\s/.test(c)) {
+              j2 += 1;
+              continue;
+            }
+            if (c === "-" && n === "-") {
+              j2 += 2;
+              while (j2 < query.length && query[j2] !== "\n" && query[j2] !== "\r") {
+                j2 += 1;
+              }
+              continue;
+            }
+            if (c === "/" && n === "*") {
+              j2 += 2;
+              while (j2 < query.length) {
+                if (query[j2] === "*" && query[j2 + 1] === "/") {
+                  j2 += 2;
+                  break;
+                }
+                j2 += 1;
+              }
+              continue;
+            }
+            break;
+          }
+        };
+        skipWsAndComments();
+        const tempLen = matchSqlKeywordAt(query, j2, "TEMPORARY") ?? matchSqlKeywordAt(query, j2, "TEMP");
+        if (tempLen != null) {
+          j2 += tempLen;
+          skipWsAndComments();
+        }
+        const triggerLen = matchSqlKeywordAt(query, j2, "TRIGGER");
+        if (triggerLen != null) {
+          awaitTriggerBegin = true;
+          segmentHasContent = true;
+          i += createLen - 1;
+          continue;
+        }
+        segmentHasContent = true;
+        i += createLen - 1;
+        continue;
+      }
+      const caseLen = matchSqlKeywordAt(query, i, "CASE");
+      if (caseLen != null) {
+        caseDepth += 1;
+        segmentHasContent = true;
+        i += caseLen - 1;
+        continue;
+      }
+      const beginLen = matchSqlKeywordAt(query, i, "BEGIN");
+      if (beginLen != null) {
+        if (awaitTriggerBegin) {
+          triggerBodyDepth += 1;
+          awaitTriggerBegin = false;
+        }
+        segmentHasContent = true;
+        i += beginLen - 1;
+        continue;
+      }
+      const endLen = matchSqlKeywordAt(query, i, "END");
+      if (endLen != null) {
+        if (caseDepth > 0) {
+          caseDepth -= 1;
+        } else if (triggerBodyDepth > 0) {
+          triggerBodyDepth -= 1;
+        }
+        segmentHasContent = true;
+        i += endLen - 1;
+        continue;
+      }
+      let j = i + 1;
+      while (j < query.length && /[A-Za-z0-9_]/.test(query[j])) {
+        j += 1;
+      }
+      segmentHasContent = true;
+      i = j - 1;
+      continue;
+    }
+    if (ch === ";") {
+      if (triggerBodyDepth > 0 || caseDepth > 0) {
+        segmentHasContent = true;
+        continue;
+      }
+      flushSegment(i);
+      continue;
+    }
+    if (!/\s/.test(ch)) {
+      segmentHasContent = true;
+    }
+  }
+  flushSegment(query.length);
+  return statements;
+}
+function isMultiStatement(query) {
+  return splitSqlStatements(query).length > 1;
+}
+function resolveSessionTarget(db, input) {
+  const sessionValue = input.bookmark?.trim() || input.sessionMode?.trim();
+  if (!sessionValue) {
+    return { target: db, session: null };
+  }
+  if (typeof db.withSession !== "function") {
+    throw new Error("D1 session mode/bookmark requested but withSession is not available");
+  }
+  const session = db.withSession(sessionValue);
+  return { target: session, session };
+}
+function normalizeD1BindParams(params) {
+  return params.map((value) => {
+    if (typeof value === "boolean") {
+      return value ? 1 : 0;
+    }
+    return value;
+  });
+}
+async function executeD1Query(db, input) {
+  const query = input.query?.trim();
+  if (!query) {
+    return { ok: false, error: "invalid_query", message: "query is required" };
+  }
+  const params = normalizeD1BindParams(Array.isArray(input.params) ? input.params : []);
+  const { target, session } = resolveSessionTarget(db, input);
+  if (isMultiStatement(query)) {
+    if (params.length > 0) {
+      return {
+        ok: false,
+        error: "invalid_query",
+        message: "params are only supported for single prepared statements"
+      };
+    }
+    const resolveBookmark = () => session?.getBookmark() ?? null;
+    const parts = splitSqlStatements(query);
+    if (typeof target.batch === "function") {
+      const prepared = parts.map((part) => target.prepare(part));
+      const results = await target.batch(prepared);
+      const rows2 = collectRowsFromBatchResults(results);
+      return {
+        ok: true,
+        rows: rows2,
+        columns: resultColumns(rows2),
+        // Prefer returned rows; otherwise sum mutation meta.changes (not statement count).
+        count: rows2.length > 0 ? rows2.length : sumBatchAffectedRows(results, parts.length),
+        bookmark: resolveBookmark(),
+        meta: { statementCount: parts.length, results },
+        statementCount: parts.length
+      };
+    }
+    const canExec = typeof target.exec === "function" && !session;
+    if (canExec) {
+      const execResult = await target.exec(query);
+      return {
+        ok: true,
+        rows: [],
+        columns: [],
+        durationMs: execResult.duration,
+        count: execResult.count,
+        bookmark: resolveBookmark(),
+        meta: { statementCount: execResult.count },
+        statementCount: execResult.count
+      };
+    }
+    return {
+      ok: false,
+      error: "invalid_query",
+      message: "multi-statement query requires D1 batch() or exec() support"
+    };
+  }
+  let statement = target.prepare(query);
+  if (params.length > 0) {
+    statement = statement.bind(...params);
+  }
+  const expectsRows = statementExpectsResultRows(query);
+  const result = expectsRows ? await statement.all() : await statement.run();
+  if (result.success === false) {
+    const errorField = result.error;
+    const message = typeof errorField === "string" && errorField.trim() ? errorField : "D1 query failed";
+    return {
+      ok: false,
+      error: "query_failed",
+      message
+    };
+  }
+  const rows = Array.isArray(result.results) ? result.results : [];
+  const bookmark = session?.getBookmark() ?? null;
+  const meta = result.meta ?? {};
+  const changes = typeof meta.changes === "number" ? meta.changes : typeof result.meta?.changes === "number" ? result.meta.changes : void 0;
+  return {
+    ok: true,
+    rows,
+    columns: resultColumns(rows),
+    durationMs: typeof result.meta?.duration === "number" ? result.meta.duration : void 0,
+    count: expectsRows ? rows.length : changes ?? rows.length,
+    bookmark,
+    meta
+  };
+}
+async function executeD1Batch(db, input) {
+  const statements = Array.isArray(input.statements) ? input.statements : [];
+  if (statements.length === 0) {
+    return {
+      ok: false,
+      error: "invalid_batch",
+      message: "statements must contain at least one item"
+    };
+  }
+  const { target, session } = resolveSessionTarget(db, input);
+  const prepared = statements.map((item) => {
+    const query = item.query?.trim();
+    if (!query) {
+      throw new Error("statements[].query is required");
+    }
+    const params = normalizeD1BindParams(Array.isArray(item.params) ? item.params : []);
+    let statement = target.prepare(query);
+    if (params.length > 0) {
+      statement = statement.bind(...params);
+    }
+    return statement;
+  });
+  const results = await target.batch(prepared);
+  const bookmark = session?.getBookmark() ?? null;
+  return {
+    ok: true,
+    results,
+    bookmark
+  };
+}
+
+// src/cloudflare/d1/sql.ts
+function asSingle(sql, params) {
+  return { sql, params };
+}
+function asBatch(statements) {
+  if (statements.length === 0) {
+    throw new D1SqlCompileError("empty_insert", "batch requires at least one statement");
+  }
+  return {
+    sql: statements[0].sql,
+    params: statements[0].params,
+    statements
+  };
+}
+function hasPaginationBounds(payload) {
+  return payload.limit !== void 0 || payload.offset !== void 0 || payload.page_size !== void 0 || payload.current_page !== void 0;
+}
+function assertEffectiveMutationBounds(payload) {
+  if (payload.current_page !== void 0 && payload.page_size === void 0 && payload.limit === void 0) {
+    throw new D1SqlCompileError(
+      "page_without_size",
+      "current_page requires page_size (or limit) for bounded update/delete on D1 edge-local"
+    );
+  }
+  const clause = limitOffsetClause(payload);
+  if (!clause.trim()) {
+    throw new D1SqlCompileError(
+      "invalid_pagination_bounds",
+      "Bounded update/delete requires limit, offset, and/or page_size on D1 edge-local"
+    );
+  }
+}
+var SQLITE_ROWID_ALIASES = /* @__PURE__ */ new Set(["rowid", "oid", "_rowid_"]);
+function referencedMutationColumns(payload) {
+  const names = [];
+  for (const condition of payload.conditions ?? []) {
+    const column = (condition.column ?? condition.eq_column ?? "").trim();
+    if (column) names.push(column);
+  }
+  if (payload.sort_by?.field?.trim()) {
+    names.push(payload.sort_by.field.trim());
+  }
+  return names;
+}
+function resolveBoundedIdentityColumn(payload, options) {
+  const refs = referencedMutationColumns(payload);
+  const lower = refs.map((name) => name.toLowerCase());
+  if (lower.some((name) => SQLITE_ROWID_ALIASES.has(name))) {
+    throw new D1SqlCompileError(
+      "bounded_mutation_unsafe_identity",
+      "Bounded update/delete cannot use rowid/oid/_rowid_ in filters or order \u2014 those names may be user columns that shadow SQLite row identity. Resolve the table primary key (or a single-column unique index) instead."
+    );
+  }
+  const identity = options?.identityColumn?.trim();
+  if (!identity) {
+    throw new D1SqlCompileError(
+      "bounded_mutation_no_unique_identity",
+      "Bounded update/delete requires a proven unique identity column from the table schema (single-column PRIMARY KEY or UNIQUE index). Cannot assume a column named id."
+    );
+  }
+  if (SQLITE_ROWID_ALIASES.has(identity.toLowerCase())) {
+    throw new D1SqlCompileError(
+      "bounded_mutation_unsafe_identity",
+      `Bounded update/delete cannot use identity column "${identity}" \u2014 it may shadow SQLite row identity.`
+    );
+  }
+  return identity;
+}
+function boundedRowidInClause(table2, whereSql, whereParams, payload, options) {
+  assertEffectiveMutationBounds(payload);
+  const identity = resolveBoundedIdentityColumn(payload, options);
+  const identitySql = quoteIdent(identity);
+  const innerWhere = whereSql.replace(/^WHERE\s+/i, "");
+  const parts = [
+    `SELECT ${identitySql} FROM ${quoteIdent(table2)}`,
+    innerWhere ? `WHERE ${innerWhere}` : "",
+    orderClause(payload.sort_by),
+    limitOffsetClause(payload)
+  ].filter(Boolean);
+  return {
+    sql: `${identitySql} IN (${parts.join(" ")})`,
+    params: [...whereParams]
+  };
+}
+var D1SqlCompileError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "D1SqlCompileError";
+    this.code = code;
+  }
+};
+var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function quoteIdent(name) {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new D1SqlCompileError("invalid_identifier", "Identifier is required");
+  }
+  if (trimmed.includes(".")) {
+    throw new D1SqlCompileError(
+      "schema_qualified_name",
+      `Schema-qualified names are unsupported on D1 edge-local: ${trimmed}`
+    );
+  }
+  if (!SAFE_IDENTIFIER.test(trimmed)) {
+    throw new D1SqlCompileError(
+      "invalid_identifier",
+      `Invalid SQL identifier for D1 edge-local: ${trimmed}`
+    );
+  }
+  return quoteQualifiedIdentifier(trimmed);
+}
+var RESPONSE_ALIAS_PATTERN2 = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/;
+var SQL_ALIAS_PATTERN2 = /^([A-Za-z_][A-Za-z0-9_]*)\s+(?:as\s+)?([A-Za-z_][A-Za-z0-9_]*)$/i;
+function quoteSelectTokenStrict(token) {
+  const trimmed = token.trim();
+  if (!trimmed || trimmed === "*") return trimmed || "*";
+  if (SAFE_IDENTIFIER.test(trimmed)) {
+    return quoteQualifiedIdentifier(trimmed);
+  }
+  const responseAlias = RESPONSE_ALIAS_PATTERN2.exec(trimmed);
+  if (responseAlias) {
+    const [, aliasIdentifier, baseIdentifier] = responseAlias;
+    return `${quoteQualifiedIdentifier(baseIdentifier)} AS ${quoteQualifiedIdentifier(aliasIdentifier)}`;
+  }
+  const sqlAlias = SQL_ALIAS_PATTERN2.exec(trimmed);
+  if (sqlAlias) {
+    const [, baseIdentifier, aliasIdentifier] = sqlAlias;
+    return `${quoteQualifiedIdentifier(baseIdentifier)} AS ${quoteQualifiedIdentifier(aliasIdentifier)}`;
+  }
+  throw new D1SqlCompileError(
+    "unsafe_select",
+    `SELECT/RETURNING expressions are not supported on D1 edge-local; use column names or aliases only: ${token}`
+  );
+}
+function selectClause(columns) {
+  if (columns === void 0 || columns === "*" || columns === "") return "*";
+  if (typeof columns === "string") {
+    const trimmed = columns.trim();
+    if (!trimmed || trimmed === "*") return "*";
+    return trimmed.split(",").map((part) => quoteSelectTokenStrict(part)).join(", ");
+  }
+  if (columns.length === 0) return "*";
+  return columns.map((column) => quoteSelectTokenStrict(column)).join(", ");
+}
+function wantsReturning(payload) {
+  return Boolean(payload.columns) && payload.head !== true;
+}
+function conditionToWhere(condition) {
+  const column = condition.column?.trim() || condition.eq_column?.trim() || "";
+  if (!column) {
+    throw new D1SqlCompileError("invalid_condition", "Condition requires a column");
+  }
+  const col = quoteIdent(column);
+  const operator = (condition.operator || "eq").toLowerCase();
+  const value = condition.value !== void 0 ? condition.value : condition.eq_value;
+  switch (operator) {
+    case "eq": {
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          return { sql: "1 = 0", params: [] };
+        }
+        const placeholders = value.map(() => "?").join(", ");
+        return { sql: `${col} IN (${placeholders})`, params: [...value] };
+      }
+      if (value === null) {
+        return { sql: `${col} IS NULL`, params: [] };
+      }
+      return { sql: `${col} = ?`, params: [value ?? null] };
+    }
+    case "neq":
+      if (value === null) {
+        return { sql: `${col} IS NOT NULL`, params: [] };
+      }
+      return { sql: `${col} != ?`, params: [value ?? null] };
+    case "gt":
+      return { sql: `${col} > ?`, params: [value ?? null] };
+    case "gte":
+      return { sql: `${col} >= ?`, params: [value ?? null] };
+    case "lt":
+      return { sql: `${col} < ?`, params: [value ?? null] };
+    case "lte":
+      return { sql: `${col} <= ?`, params: [value ?? null] };
+    case "like":
+      return { sql: `${col} LIKE ?`, params: [value ?? null] };
+    case "ilike":
+      return { sql: `${col} LIKE ? COLLATE NOCASE`, params: [value ?? null] };
+    case "in": {
+      const items = Array.isArray(value) ? value : value === void 0 ? [] : [value];
+      if (items.length === 0) {
+        return { sql: "1 = 0", params: [] };
+      }
+      const placeholders = items.map(() => "?").join(", ");
+      return { sql: `${col} IN (${placeholders})`, params: [...items] };
+    }
+    case "is": {
+      if (value === null || value === "null") {
+        return { sql: `${col} IS NULL`, params: [] };
+      }
+      if (value === true || value === "true") {
+        return { sql: `${col} IS TRUE`, params: [] };
+      }
+      if (value === false || value === "false") {
+        return { sql: `${col} IS FALSE`, params: [] };
+      }
+      return { sql: `${col} IS ?`, params: [value] };
+    }
+    case "not":
+    case "or":
+    case "contains":
+    case "containedby":
+      throw new D1SqlCompileError(
+        "unsupported_operator",
+        `Condition operator "${operator}" is not supported on D1 edge-local L1`
+      );
+    default:
+      throw new D1SqlCompileError(
+        "unsupported_operator",
+        `Unknown condition operator "${operator}"`
+      );
+  }
+}
+function buildWhere(conditions) {
+  if (!conditions?.length) {
+    return { sql: "", params: [] };
+  }
+  const parts = [];
+  const params = [];
+  for (const condition of conditions) {
+    if (!condition.operator && condition.eq_column) {
+      const clause2 = conditionToWhere({
+        ...condition,
+        operator: "eq",
+        column: condition.eq_column,
+        value: condition.eq_value
+      });
+      parts.push(clause2.sql);
+      params.push(...clause2.params);
+      continue;
+    }
+    const clause = conditionToWhere(condition);
+    parts.push(clause.sql);
+    params.push(...clause.params);
+  }
+  return {
+    sql: parts.length ? `WHERE ${parts.join(" AND ")}` : "",
+    params
+  };
+}
+function orderClause(order) {
+  if (!order?.field?.trim()) return "";
+  const direction = order.direction === "descending" ? "DESC" : "ASC";
+  return `ORDER BY ${quoteIdent(order.field)} ${direction}`;
+}
+function limitOffsetClause(payload) {
+  let limit = payload.limit;
+  let offset = payload.offset;
+  if (limit === void 0 && payload.page_size !== void 0) {
+    limit = payload.page_size;
+  }
+  if (payload.current_page !== void 0 && offset === void 0) {
+    const pageSize = payload.page_size ?? payload.limit;
+    if (pageSize !== void 0) {
+      offset = Math.max(0, (payload.current_page - 1) * pageSize);
+    }
+  }
+  const parts = [];
+  if (offset !== void 0 && limit === void 0) {
+    parts.push("LIMIT -1");
+    parts.push(`OFFSET ${Math.max(0, Math.trunc(offset))}`);
+  } else {
+    if (limit !== void 0) {
+      parts.push(`LIMIT ${Math.max(0, Math.trunc(limit))}`);
+    }
+    if (offset !== void 0) {
+      parts.push(`OFFSET ${Math.max(0, Math.trunc(offset))}`);
+    }
+  }
+  return parts.join(" ");
+}
+function rejectStructuredRelations(payload) {
+  const select = payload.select;
+  if (select && typeof select === "object" && !Array.isArray(select)) {
+    for (const value of Object.values(select)) {
+      if (value && typeof value === "object") {
+        throw new D1SqlCompileError(
+          "relations_unsupported",
+          "Nested relation selects are unsupported on D1 edge-local"
+        );
+      }
+    }
+  }
+  if (payload.view_name) {
+    throw new D1SqlCompileError(
+      "view_unsupported",
+      "view_name is unsupported on D1 edge-local L1"
+    );
+  }
+}
+function jsonValue(value) {
+  if (value === void 0) return null;
+  if (value !== null && typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function compileD1Fetch(payload) {
+  rejectStructuredRelations(payload);
+  const table2 = payload.table_name?.trim();
+  if (!table2) {
+    throw new D1SqlCompileError("missing_table", "table_name is required for fetch");
+  }
+  let columns = payload.columns;
+  if (payload.select && typeof payload.select === "object" && !Array.isArray(payload.select)) {
+    const keys = Object.entries(payload.select).filter(([, enabled]) => enabled === true || enabled === 1).map(([key]) => key);
+    if (keys.length > 0) {
+      columns = keys;
+    }
+  } else if (typeof payload.select === "string" && payload.select.trim()) {
+    columns = payload.select;
+  }
+  let where = buildWhere(payload.conditions);
+  if (!where.sql && payload.where && typeof payload.where === "object") {
+    const eqConditions = Object.entries(
+      payload.where
+    ).map(([column, value]) => ({
+      column,
+      operator: "eq",
+      value
+    }));
+    where = buildWhere(eqConditions);
+  }
+  if (payload.head === true) {
+    return compileD1CountFromWhere(table2, where);
+  }
+  const parts = [
+    `SELECT ${selectClause(columns)} FROM ${quoteIdent(table2)}`,
+    where.sql,
+    orderClause(payload.sort_by),
+    limitOffsetClause(payload)
+  ].filter(Boolean);
+  return asSingle(parts.join(" "), where.params);
+}
+function compileD1Count(payload) {
+  rejectStructuredRelations(payload);
+  const table2 = payload.table_name?.trim();
+  if (!table2) {
+    throw new D1SqlCompileError("missing_table", "table_name is required for count");
+  }
+  let where = buildWhere(payload.conditions);
+  if (!where.sql && payload.where && typeof payload.where === "object") {
+    const eqConditions = Object.entries(
+      payload.where
+    ).map(([column, value]) => ({
+      column,
+      operator: "eq",
+      value
+    }));
+    where = buildWhere(eqConditions);
+  }
+  return compileD1CountFromWhere(table2, where);
+}
+function compileD1CountFromWhere(table2, where) {
+  const parts = [
+    `SELECT COUNT(*) AS __athena_count FROM ${quoteIdent(table2)}`,
+    where.sql
+  ].filter(Boolean);
+  return asSingle(parts.join(" "), where.params);
+}
+function extractAthenaCount(rows) {
+  const first = rows[0];
+  const rawCount = first && typeof first === "object" && !Array.isArray(first) ? first.__athena_count : void 0;
+  const count = typeof rawCount === "number" ? rawCount : typeof rawCount === "bigint" ? Number(rawCount) : Number(rawCount ?? 0);
+  return Number.isFinite(count) ? count : 0;
+}
+function compileSingleRowInsert(table2, row, payload) {
+  const columns = Object.keys(row);
+  if (columns.length === 0) {
+    if (payload.on_conflict) {
+      throw new D1SqlCompileError(
+        "default_values_upsert_unsupported",
+        "DEFAULT VALUES upsert is unsupported on D1 edge-local; provide insert columns or omit onConflict"
+      );
+    }
+    const parts2 = [`INSERT INTO ${quoteIdent(table2)} DEFAULT VALUES`];
+    if (wantsReturning(payload)) {
+      parts2.push(`RETURNING ${selectClause(payload.columns)}`);
+    }
+    return { sql: parts2.join(" "), params: [] };
+  }
+  const params = columns.map((column) => jsonValue(row[column]));
+  const parts = [
+    `INSERT INTO ${quoteIdent(table2)} (${columns.map(quoteIdent).join(", ")})`,
+    `VALUES (${columns.map(() => "?").join(", ")})`
+  ];
+  appendOnConflict(parts, params, payload, columns);
+  if (wantsReturning(payload)) {
+    parts.push(`RETURNING ${selectClause(payload.columns)}`);
+  }
+  return { sql: parts.join(" "), params };
+}
+function parseOnConflictColumns(onConflict) {
+  const raw = Array.isArray(onConflict) ? onConflict : [onConflict];
+  const columns = [];
+  for (const item of raw) {
+    for (const part of String(item).split(",")) {
+      const trimmed = part.trim();
+      if (trimmed) columns.push(trimmed);
+    }
+  }
+  if (columns.length === 0) {
+    throw new D1SqlCompileError(
+      "invalid_on_conflict",
+      "on_conflict requires at least one column"
+    );
+  }
+  return columns;
+}
+function appendOnConflict(parts, params, payload, insertColumns) {
+  if (!payload.on_conflict) return;
+  const conflictCols = parseOnConflictColumns(payload.on_conflict);
+  const conflictSql = conflictCols.map(quoteIdent).join(", ");
+  if (payload.update_body !== void 0 && payload.update_body !== null) {
+    const entries = Object.entries(payload.update_body);
+    if (entries.length === 0) {
+      parts.push(`ON CONFLICT (${conflictSql}) DO NOTHING`);
+      return;
+    }
+    const assignments2 = entries.map(([column, value]) => {
+      params.push(jsonValue(value));
+      return `${quoteIdent(column)} = ?`;
+    });
+    parts.push(`ON CONFLICT (${conflictSql}) DO UPDATE SET ${assignments2.join(", ")}`);
+    return;
+  }
+  const conflictSet = new Set(conflictCols);
+  const assignments = insertColumns.filter((column) => !conflictSet.has(column)).map((column) => {
+    const quoted = quoteIdent(column);
+    return `${quoted} = excluded.${quoted}`;
+  });
+  if (assignments.length === 0) {
+    parts.push(`ON CONFLICT (${conflictSql}) DO NOTHING`);
+  } else {
+    parts.push(`ON CONFLICT (${conflictSql}) DO UPDATE SET ${assignments.join(", ")}`);
+  }
+}
+function compileD1Insert(payload) {
+  const table2 = payload.table_name?.trim();
+  if (!table2) {
+    throw new D1SqlCompileError("missing_table", "table_name is required for insert");
+  }
+  const rows = Array.isArray(payload.insert_body) ? payload.insert_body : [payload.insert_body];
+  if (rows.length === 0) {
+    throw new D1SqlCompileError("empty_insert", "insert_body must not be empty");
+  }
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row ?? {})) {
+      if (seen.has(key)) continue;
+      seen.add(key);
+      columns.push(key);
+    }
+  }
+  if (columns.length === 0) {
+    if (rows.length === 1) {
+      const compiled = compileSingleRowInsert(table2, {}, payload);
+      return asSingle(compiled.sql, compiled.params);
+    }
+    throw new D1SqlCompileError(
+      "empty_insert",
+      "Multi-row insert_body cannot be empty objects; use a single {} for DEFAULT VALUES"
+    );
+  }
+  const forceNullForMissing = payload.default_to_null === true;
+  const isSparse = rows.some(
+    (row) => columns.some((column) => !Object.prototype.hasOwnProperty.call(row, column))
+  );
+  if (isSparse && !forceNullForMissing && rows.length > 1) {
+    return asBatch(
+      rows.map((row) => compileSingleRowInsert(table2, row, payload))
+    );
+  }
+  if (isSparse && !forceNullForMissing && rows.length === 1) {
+    const compiled = compileSingleRowInsert(table2, rows[0], payload);
+    return asSingle(compiled.sql, compiled.params);
+  }
+  const params = [];
+  const valueGroups = rows.map((row) => {
+    const placeholders = columns.map((column) => {
+      const has = Object.prototype.hasOwnProperty.call(row, column);
+      if (!has) {
+        params.push(null);
+        return "?";
+      }
+      params.push(jsonValue(row[column]));
+      return "?";
+    });
+    return `(${placeholders.join(", ")})`;
+  });
+  const parts = [
+    `INSERT INTO ${quoteIdent(table2)} (${columns.map(quoteIdent).join(", ")})`,
+    `VALUES ${valueGroups.join(", ")}`
+  ];
+  appendOnConflict(parts, params, payload, columns);
+  if (wantsReturning(payload)) {
+    parts.push(`RETURNING ${selectClause(payload.columns)}`);
+  }
+  return asSingle(parts.join(" "), params);
+}
+function compileD1Update(payload, options) {
+  const table2 = payload.table_name?.trim();
+  if (!table2) {
+    throw new D1SqlCompileError("missing_table", "table_name is required for update");
+  }
+  const entries = Object.entries(payload.update_body ?? {});
+  if (entries.length === 0) {
+    throw new D1SqlCompileError("empty_update", "update_body must not be empty");
+  }
+  const params = [];
+  const assignments = entries.map(([column, value]) => {
+    params.push(jsonValue(value));
+    return `${quoteIdent(column)} = ?`;
+  });
+  const where = buildWhere(payload.conditions);
+  if (!where.sql) {
+    throw new D1SqlCompileError(
+      "unfiltered_update",
+      "UPDATE requires at least one condition on D1 edge-local"
+    );
+  }
+  if (hasPaginationBounds(payload) || payload.sort_by) {
+    if (!hasPaginationBounds(payload)) {
+      throw new D1SqlCompileError(
+        "order_without_bounds",
+        "UPDATE with sort_by requires limit/offset or page_size/current_page on D1 edge-local"
+      );
+    }
+    const bounded = boundedRowidInClause(
+      table2,
+      where.sql,
+      where.params,
+      {
+        ...payload,
+        conditions: payload.conditions
+      },
+      options
+    );
+    params.push(...bounded.params);
+    const parts2 = [
+      `UPDATE ${quoteIdent(table2)} SET ${assignments.join(", ")}`,
+      `WHERE ${bounded.sql}`
+    ];
+    if (wantsReturning(payload)) {
+      parts2.push(`RETURNING ${selectClause(payload.columns)}`);
+    }
+    return asSingle(parts2.join(" "), params);
+  }
+  params.push(...where.params);
+  const parts = [
+    `UPDATE ${quoteIdent(table2)} SET ${assignments.join(", ")}`,
+    where.sql
+  ];
+  if (wantsReturning(payload)) {
+    parts.push(`RETURNING ${selectClause(payload.columns)}`);
+  }
+  return asSingle(parts.join(" "), params);
+}
+function compileD1Delete(payload, options) {
+  const table2 = payload.table_name?.trim();
+  if (!table2) {
+    throw new D1SqlCompileError("missing_table", "table_name is required for delete");
+  }
+  const conditions = [...payload.conditions ?? []];
+  if (payload.resource_id !== void 0 && payload.resource_id !== null) {
+    const hasResourceIdFilter = conditions.some((condition) => {
+      const column = (condition.column ?? condition.eq_column ?? "").trim();
+      return column === "resource_id";
+    });
+    const hasIdFilter = conditions.some((condition) => {
+      const column = (condition.column ?? condition.eq_column ?? "").trim();
+      return column === "id";
+    });
+    if (!hasResourceIdFilter && !hasIdFilter) {
+      conditions.unshift({
+        column: "id",
+        operator: "eq",
+        value: payload.resource_id
+      });
+    }
+  }
+  const where = buildWhere(conditions);
+  if (!where.sql) {
+    throw new D1SqlCompileError(
+      "unfiltered_delete",
+      "DELETE requires at least one condition or resource_id on D1 edge-local"
+    );
+  }
+  if (hasPaginationBounds(payload) || payload.sort_by) {
+    if (!hasPaginationBounds(payload)) {
+      throw new D1SqlCompileError(
+        "order_without_bounds",
+        "DELETE with sort_by requires limit/offset or page_size/current_page on D1 edge-local"
+      );
+    }
+    const bounded = boundedRowidInClause(
+      table2,
+      where.sql,
+      where.params,
+      {
+        ...payload,
+        conditions
+      },
+      options
+    );
+    const parts2 = [`DELETE FROM ${quoteIdent(table2)}`, `WHERE ${bounded.sql}`];
+    if (wantsReturning(payload)) {
+      parts2.push(`RETURNING ${selectClause(payload.columns)}`);
+    }
+    return asSingle(parts2.join(" "), bounded.params);
+  }
+  const parts = [`DELETE FROM ${quoteIdent(table2)}`, where.sql];
+  if (wantsReturning(payload)) {
+    parts.push(`RETURNING ${selectClause(payload.columns)}`);
+  }
+  return asSingle(parts.join(" "), where.params);
+}
+
+// src/cloudflare/d1/sql-rewrite.ts
+var PG_CAST_TYPES = "text|uuid|citext|varchar|bpchar|char|integer|int4|int8|bigint|smallint|boolean|bool|jsonb|json|numeric|decimal|real|float|double precision|timestamptz|timestamp|date|bytea";
+function mapSqlOutsideLiterals(sql, transform) {
+  let out = "";
+  let buffer = "";
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inBracket = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  const flushCode = () => {
+    if (buffer) {
+      out += transform(buffer);
+      buffer = "";
+    }
+  };
+  for (let i = 0; i < sql.length; i += 1) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      out += ch;
+      if (ch === "\n" || ch === "\r") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      out += ch;
+      if (ch === "*" && next === "/") {
+        out += next;
+        i += 1;
+        inBlockComment = false;
+      }
+      continue;
+    }
+    if (inSingle) {
+      out += ch;
+      if (ch === "'" && next === "'") {
+        out += next;
+        i += 1;
+        continue;
+      }
+      if (ch === "'") inSingle = false;
+      continue;
+    }
+    if (inDouble) {
+      out += ch;
+      if (ch === '"' && next === '"') {
+        out += next;
+        i += 1;
+        continue;
+      }
+      if (ch === '"') inDouble = false;
+      continue;
+    }
+    if (inBacktick) {
+      out += ch;
+      if (ch === "`" && next === "`") {
+        out += next;
+        i += 1;
+        continue;
+      }
+      if (ch === "`") inBacktick = false;
+      continue;
+    }
+    if (inBracket) {
+      out += ch;
+      if (ch === "]") inBracket = false;
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      flushCode();
+      out += ch;
+      out += next;
+      i += 1;
+      inLineComment = true;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      flushCode();
+      out += ch;
+      out += next;
+      i += 1;
+      inBlockComment = true;
+      continue;
+    }
+    if (ch === "'") {
+      flushCode();
+      out += ch;
+      inSingle = true;
+      continue;
+    }
+    if (ch === '"') {
+      flushCode();
+      out += ch;
+      inDouble = true;
+      continue;
+    }
+    if (ch === "`") {
+      flushCode();
+      out += ch;
+      inBacktick = true;
+      continue;
+    }
+    if (ch === "[") {
+      flushCode();
+      out += ch;
+      inBracket = true;
+      continue;
+    }
+    buffer += ch;
+  }
+  flushCode();
+  return out;
+}
+function isIdentChar2(ch) {
+  if (!ch) return false;
+  return /[A-Za-z0-9_]/.test(ch);
+}
+function collectLimitOffsetKeywords(sql) {
+  const hits = [];
+  let depth = 0;
+  let statement = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inBracket = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i += 1) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      if (ch === "\n" || ch === "\r") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        i += 1;
+        inBlockComment = false;
+      }
+      continue;
+    }
+    if (inSingle) {
+      if (ch === "'" && next === "'") {
+        i += 1;
+        continue;
+      }
+      if (ch === "'") inSingle = false;
+      continue;
+    }
+    if (inDouble) {
+      if (ch === '"' && next === '"') {
+        i += 1;
+        continue;
+      }
+      if (ch === '"') inDouble = false;
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`" && next === "`") {
+        i += 1;
+        continue;
+      }
+      if (ch === "`") inBacktick = false;
+      continue;
+    }
+    if (inBracket) {
+      if (ch === "]") inBracket = false;
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      continue;
+    }
+    if (ch === "[") {
+      inBracket = true;
+      continue;
+    }
+    if (ch === "(") {
+      depth += 1;
+      continue;
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (ch === ";" && depth === 0) {
+      statement += 1;
+      continue;
+    }
+    if (!isIdentChar2(ch) || isIdentChar2(sql[i - 1])) {
+      continue;
+    }
+    const rest = sql.slice(i);
+    if (/^LIMIT\b/i.test(rest)) {
+      hits.push({ kind: "limit", start: i, depth, statement });
+      i += 4;
+      continue;
+    }
+    if (/^OFFSET\b/i.test(rest)) {
+      hits.push({ kind: "offset", start: i, depth, statement });
+      i += 5;
+    }
+  }
+  return hits;
+}
+function injectLimitBeforeBareOffsets(sql) {
+  const hits = collectLimitOffsetKeywords(sql);
+  if (hits.length === 0) return sql;
+  const injectAt = [];
+  for (const hit of hits) {
+    if (hit.kind !== "offset") continue;
+    let hasLimit = false;
+    for (let i = hits.length - 1; i >= 0; i -= 1) {
+      const prev = hits[i];
+      if (prev.start >= hit.start) continue;
+      if (prev.statement !== hit.statement) continue;
+      if (prev.depth !== hit.depth) continue;
+      if (prev.kind === "limit") {
+        hasLimit = true;
+        break;
+      }
+      if (prev.kind === "offset") {
+        break;
+      }
+    }
+    if (!hasLimit) {
+      injectAt.push(hit.start);
+    }
+  }
+  if (injectAt.length === 0) return sql;
+  let out = sql;
+  for (let i = injectAt.length - 1; i >= 0; i -= 1) {
+    const at = injectAt[i];
+    out = `${out.slice(0, at)}LIMIT -1 ${out.slice(at)}`;
+  }
+  return out;
+}
+function rewritePostgresSqlForSqlite(sql) {
+  const castPattern = new RegExp(`::(?:${PG_CAST_TYPES})\\b`, "gi");
+  const withoutCastsAndIlike = mapSqlOutsideLiterals(sql, (chunk) => {
+    let rewritten = chunk.replace(castPattern, "");
+    rewritten = rewritten.replace(/\bILIKE\b/gi, "LIKE");
+    return rewritten;
+  });
+  return injectLimitBeforeBareOffsets(withoutCastsAndIlike);
+}
+
+// src/cloudflare/d1/transport.ts
+function hasPaginationBounds2(payload) {
+  return payload.limit !== void 0 || payload.offset !== void 0 || payload.page_size !== void 0 || payload.current_page !== void 0;
+}
+function normalizeSqliteCollation(name) {
+  const raw = String(name ?? "").trim().replace(/^["'`[]|["'`\]]$/g, "");
+  if (!raw) return "BINARY";
+  return raw.toUpperCase();
+}
+function findCreateTableColumnListOpen(createSql) {
+  const m = /\bCREATE\s+(?:(?:TEMP|TEMPORARY|VIRTUAL)\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?/i.exec(
+    createSql
+  );
+  if (!m) return -1;
+  let i = m.index + m[0].length;
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inBracket = false;
+  while (i < createSql.length) {
+    const ch = createSql[i];
+    if (inSingle) {
+      if (ch === "'" && createSql[i + 1] === "'") {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") inSingle = false;
+      i++;
+      continue;
+    }
+    if (inDouble) {
+      if (ch === '"') inDouble = false;
+      i++;
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`") inBacktick = false;
+      i++;
+      continue;
+    }
+    if (inBracket) {
+      if (ch === "]") inBracket = false;
+      i++;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      inBracket = true;
+      i++;
+      continue;
+    }
+    if (ch === "(") return i;
+    i++;
+  }
+  return -1;
+}
+function parseColumnCollationFromCreateSql(createSql, columnName) {
+  if (!createSql || !columnName) return null;
+  const listOpen = findCreateTableColumnListOpen(createSql);
+  if (listOpen < 0) return null;
+  const listStart = listOpen + 1;
+  const escaped = columnName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const nameRe = new RegExp(
+    `(?:^|[^\\w])(?:"${escaped}"|\`${escaped}\`|\\[${escaped}\\]|${escaped})\\s+`,
+    "i"
+  );
+  const listSlice = createSql.slice(listStart);
+  let nameMatchAbs = -1;
+  let nameMatchLen = 0;
+  {
+    let i2 = 0;
+    let depth2 = 1;
+    let inSingle2 = false;
+    let inDouble2 = false;
+    let inBacktick2 = false;
+    let inBracket2 = false;
+    let segmentStart = 0;
+    const trySegment = (from, to) => {
+      if (nameMatchAbs >= 0) return;
+      const segment = listSlice.slice(from, to);
+      const m = nameRe.exec(segment);
+      if (!m) return;
+      const leading = segment.slice(0, m.index).trim();
+      if (leading.length > 0) return;
+      nameMatchAbs = listStart + from + m.index;
+      nameMatchLen = m[0].length;
+    };
+    while (i2 < listSlice.length && depth2 > 0) {
+      const ch = listSlice[i2];
+      if (inSingle2) {
+        if (ch === "'" && listSlice[i2 + 1] === "'") {
+          i2 += 2;
+          continue;
+        }
+        if (ch === "'") inSingle2 = false;
+        i2++;
+        continue;
+      }
+      if (inDouble2) {
+        if (ch === '"') inDouble2 = false;
+        i2++;
+        continue;
+      }
+      if (inBacktick2) {
+        if (ch === "`") inBacktick2 = false;
+        i2++;
+        continue;
+      }
+      if (inBracket2) {
+        if (ch === "]") inBracket2 = false;
+        i2++;
+        continue;
+      }
+      if (ch === "'") {
+        inSingle2 = true;
+        i2++;
+        continue;
+      }
+      if (ch === '"') {
+        inDouble2 = true;
+        i2++;
+        continue;
+      }
+      if (ch === "`") {
+        inBacktick2 = true;
+        i2++;
+        continue;
+      }
+      if (ch === "[") {
+        inBracket2 = true;
+        i2++;
+        continue;
+      }
+      if (ch === "(") {
+        depth2++;
+        i2++;
+        continue;
+      }
+      if (ch === ")") {
+        depth2--;
+        if (depth2 === 0) {
+          trySegment(segmentStart, i2);
+          break;
+        }
+        i2++;
+        continue;
+      }
+      if (ch === "," && depth2 === 1) {
+        trySegment(segmentStart, i2);
+        segmentStart = i2 + 1;
+        i2++;
+        continue;
+      }
+      i2++;
+    }
+  }
+  if (nameMatchAbs < 0 || nameMatchLen <= 0) return null;
+  const start = nameMatchAbs + nameMatchLen;
+  let i = start;
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inBracket = false;
+  while (i < createSql.length) {
+    const ch = createSql[i];
+    if (inSingle) {
+      if (ch === "'" && createSql[i + 1] === "'") {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") inSingle = false;
+      i++;
+      continue;
+    }
+    if (inDouble) {
+      if (ch === '"') inDouble = false;
+      i++;
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`") inBacktick = false;
+      i++;
+      continue;
+    }
+    if (inBracket) {
+      if (ch === "]") inBracket = false;
+      i++;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      inBracket = true;
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      if (depth === 0) {
+        break;
+      }
+      depth--;
+      i++;
+      continue;
+    }
+    if (ch === "," && depth === 0) {
+      break;
+    }
+    i++;
+  }
+  const colDef = createSql.slice(start, i);
+  const collRe = /\bCOLLATE\s+("([^"]+)"|'([^']+)'|`([^`]+)`|\[([^\]]+)\]|([A-Za-z_][\w$]*))/i;
+  const match = collRe.exec(colDef);
+  if (!match) return null;
+  return match[2] ?? match[3] ?? match[4] ?? match[5] ?? match[6] ?? match[1] ?? null;
+}
+async function indexCollationMatchesColumn(d1, table2, tableSafe, indexSafe, columnName, session) {
+  const xinfo = await executeD1Query(d1, {
+    query: `PRAGMA index_xinfo("${indexSafe}")`,
+    params: [],
+    ...session
+  });
+  if (!xinfo.ok) {
+    return false;
+  }
+  const xRows = xinfo.rows ?? [];
+  const keyRows = xRows.filter((row) => {
+    const isKey = row.key === 1 || row.key === true || Number(row.key) === 1;
+    if (!isKey) return false;
+    return typeof row.name === "string" && row.name === columnName;
+  });
+  if (keyRows.length === 0) {
+    const byName = xRows.find(
+      (row) => typeof row.name === "string" && row.name === columnName
+    );
+    if (!byName) return false;
+    keyRows.push(byName);
+  }
+  const indexColl = normalizeSqliteCollation(keyRows[0]?.coll);
+  const master = await executeD1Query(d1, {
+    query: `SELECT sql AS create_sql FROM sqlite_master WHERE type = 'table' AND name = ?`,
+    params: [table2],
+    ...session
+  });
+  let createSql = "";
+  if (master.ok && Array.isArray(master.rows) && master.rows.length > 0) {
+    createSql = String(
+      master.rows[0]?.create_sql ?? ""
+    );
+  }
+  const columnCollRaw = parseColumnCollationFromCreateSql(createSql, columnName);
+  const columnColl = normalizeSqliteCollation(columnCollRaw);
+  return indexColl === columnColl;
+}
+async function resolveD1BoundedIdentityColumn(d1, tableName, session) {
+  const table2 = tableName.trim();
+  if (!table2) {
+    throw new D1SqlCompileError("missing_table", "table_name is required for bounded mutation");
+  }
+  const safe = table2.replace(/"/g, '""');
+  const info = await executeD1Query(d1, {
+    query: `PRAGMA table_info("${safe}")`,
+    params: [],
+    ...session
+  });
+  if (!info.ok) {
+    throw new D1SqlCompileError(
+      "bounded_mutation_no_unique_identity",
+      `Unable to introspect table "${table2}" for bounded mutation identity: ${info.message}`
+    );
+  }
+  const cols = info.rows.filter(
+    (row) => typeof row?.name === "string" && row.name.length > 0
+  );
+  const colByName = new Map(cols.map((col) => [col.name, col]));
+  const isNotNullColumn = (name) => {
+    const col = colByName.get(name);
+    if (!col) return false;
+    return col.notnull === 1 || col.notnull === true || Number(col.notnull) === 1;
+  };
+  const isIntegerPrimaryKeyType = (col) => {
+    if (typeof col.pk !== "number" || col.pk <= 0) return false;
+    const declared = String(col.type ?? "").trim().toUpperCase();
+    return declared === "INTEGER";
+  };
+  const loadIndexList = async () => {
+    const indexList = await executeD1Query(d1, {
+      query: `PRAGMA index_list("${safe}")`,
+      params: [],
+      ...session
+    });
+    if (!indexList.ok) return null;
+    return indexList.rows;
+  };
+  const isDescendingIntegerPrimaryKeyException = async (colName, indexes) => {
+    if (indexes) {
+      const hasPkOrigin = indexes.some(
+        (index) => String(index.origin ?? "").toLowerCase() === "pk"
+      );
+      if (hasPkOrigin) return true;
+      const originReported = indexes.some(
+        (index) => index.origin !== void 0 && index.origin !== null && String(index.origin).length > 0
+      );
+      if (indexes.length === 0 || originReported) {
+        return false;
+      }
+    }
+    const master = await executeD1Query(d1, {
+      query: `SELECT sql AS create_sql FROM sqlite_master WHERE type = 'table' AND name = ?`,
+      params: [table2],
+      ...session
+    });
+    if (!master.ok || !Array.isArray(master.rows) || master.rows.length === 0) {
+      return false;
+    }
+    const createSql = String(
+      master.rows[0]?.create_sql ?? ""
+    );
+    if (!createSql) return false;
+    const escaped = colName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const inlineDesc = new RegExp(
+      `(?:^|[^\\w])(?:"${escaped}"|${escaped})\\s+INTEGER\\s+PRIMARY\\s+KEY\\s+DESC\\b`,
+      "i"
+    );
+    const tableDesc = new RegExp(
+      `PRIMARY\\s+KEY\\s*\\(\\s*(?:"${escaped}"|${escaped})\\s+DESC\\b`,
+      "i"
+    );
+    return inlineDesc.test(createSql) || tableDesc.test(createSql);
+  };
+  const pkCols = cols.filter((row) => typeof row.pk === "number" && row.pk > 0).sort((a, b) => (a.pk ?? 0) - (b.pk ?? 0));
+  let indexRows;
+  if (pkCols.length === 1 && pkCols[0]?.name) {
+    if (isIntegerPrimaryKeyType(pkCols[0])) {
+      indexRows = await loadIndexList();
+      const isDescException = await isDescendingIntegerPrimaryKeyException(
+        pkCols[0].name,
+        indexRows
+      );
+      if (!isDescException) {
+        return pkCols[0].name;
+      }
+    } else if (isNotNullColumn(pkCols[0].name)) {
+      indexRows = await loadIndexList();
+      const pkIndex = (indexRows ?? []).find(
+        (index) => String(index.origin ?? "").toLowerCase() === "pk"
+      );
+      if (pkIndex && typeof pkIndex.name === "string" && pkIndex.name) {
+        const indexSafe = pkIndex.name.replace(/"/g, '""');
+        const collMatch = await indexCollationMatchesColumn(
+          d1,
+          table2,
+          safe,
+          indexSafe,
+          pkCols[0].name,
+          session
+        );
+        if (collMatch) {
+          return pkCols[0].name;
+        }
+      }
+    }
+  }
+  if (indexRows === void 0) {
+    indexRows = await loadIndexList();
+  }
+  if (indexRows) {
+    for (const index of indexRows) {
+      const unique = index.unique === 1 || index.unique === true || Number(index.unique) === 1;
+      if (!unique || typeof index.name !== "string" || !index.name) continue;
+      const isPartial = index.partial === 1 || index.partial === true || Number(index.partial) === 1;
+      if (isPartial) {
+        continue;
+      }
+      const indexSafe = index.name.replace(/"/g, '""');
+      const indexInfo = await executeD1Query(d1, {
+        query: `PRAGMA index_info("${indexSafe}")`,
+        params: [],
+        ...session
+      });
+      if (!indexInfo.ok) continue;
+      const rawIndexCols = indexInfo.rows ?? [];
+      const hasExpressionTerm = rawIndexCols.some((row) => {
+        const nameOk = typeof row?.name === "string" && row.name.length > 0;
+        if (!nameOk) return true;
+        if (typeof row.cid === "number" && row.cid < 0) return true;
+        return false;
+      });
+      if (hasExpressionTerm || rawIndexCols.length === 0) {
+        continue;
+      }
+      const indexCols = rawIndexCols.filter(
+        (row) => typeof row?.name === "string" && row.name.length > 0
+      );
+      if (indexCols.length === 1 && indexCols[0]?.name) {
+        const identity = indexCols[0].name;
+        if (!isNotNullColumn(identity)) {
+          continue;
+        }
+        const collMatch = await indexCollationMatchesColumn(
+          d1,
+          table2,
+          safe,
+          indexSafe,
+          identity,
+          session
+        );
+        if (!collMatch) {
+          continue;
+        }
+        return identity;
+      }
+    }
+  }
+  throw new D1SqlCompileError(
+    "bounded_mutation_no_unique_identity",
+    `Bounded update/delete on "${table2}" requires a proven single-column PRIMARY KEY or UNIQUE index`
+  );
+}
+async function compileOptionsForBoundedMutation(d1, payload, session) {
+  if (!hasPaginationBounds2(payload) && !payload.sort_by) {
+    return void 0;
+  }
+  if (!hasPaginationBounds2(payload)) {
+    return void 0;
+  }
+  const identityColumn = await resolveD1BoundedIdentityColumn(
+    d1,
+    payload.table_name ?? "",
+    session
+  );
+  return { identityColumn };
+}
+function headerValue2(options, name) {
+  const headers = options?.headers;
+  if (!headers) return void 0;
+  const lower = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lower && value?.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function sessionFromOptions(options, defaults) {
+  return {
+    bookmark: headerValue2(options, "x-athena-d1-bookmark") ?? null,
+    sessionMode: headerValue2(options, "x-athena-d1-session-mode") ?? defaults.defaultSessionMode ?? null
+  };
+}
+function resolveStripNulls(payloadStrip, callOptions, defaultValue = true) {
+  if (typeof payloadStrip === "boolean") return payloadStrip;
+  if (typeof callOptions?.stripNulls === "boolean") return callOptions.stripNulls;
+  return defaultValue;
+}
+function stripNullPropertiesFromRows(rows) {
+  return rows.map((row) => {
+    if (row == null || typeof row !== "object" || Array.isArray(row)) {
+      return row;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (value !== null) {
+        out[key] = value;
+      }
+    }
+    return out;
+  });
+}
+function maybeStripNullRows(rows, strip) {
+  return strip ? stripNullPropertiesFromRows(rows) : rows;
+}
+function successResponse(data, count, raw, bookmark) {
+  const response = {
+    ok: true,
+    status: 200,
+    statusText: "OK",
+    data,
+    count: count ?? null,
+    error: void 0,
+    errorDetails: null,
+    raw
+  };
+  if (bookmark) {
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      const rawRecord = raw;
+      rawRecord.bookmark = bookmark;
+    }
+  }
+  return response;
+}
+function errorResponse(status, code, message, endpoint, method, hint) {
+  const error = new AthenaGatewayError({
+    code,
+    message,
+    status,
+    endpoint,
+    method,
+    hint
+  });
+  return {
+    ok: false,
+    status,
+    statusText: null,
+    data: null,
+    error: error.message,
+    errorDetails: error.toDetails(),
+    raw: { error: message, code }
+  };
+}
+function compileErrorResponse(error, endpoint, method) {
+  if (error instanceof D1SqlCompileError) {
+    return errorResponse(
+      400,
+      "HTTP_ERROR",
+      error.message,
+      endpoint,
+      method,
+      `D1 SQL compile failed (${error.code})`
+    );
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return errorResponse(500, "UNKNOWN_ERROR", message, endpoint, method);
+}
+function createCloudflareD1GatewayTransport(options) {
+  const { d1 } = options;
+  async function runCompiled(compiled, callOptions, endpoint, method, mapResult, stripNulls = true) {
+    try {
+      const session = sessionFromOptions(callOptions, options);
+      if (compiled.statements && compiled.statements.length > 1) {
+        const batch = await executeD1Batch(d1, {
+          statements: compiled.statements.map((statement) => ({
+            query: statement.sql,
+            params: statement.params
+          })),
+          ...session
+        });
+        if (!batch.ok) {
+          return errorResponse(400, "HTTP_ERROR", batch.message, endpoint, method);
+        }
+        const rows2 = maybeStripNullRows(
+          batch.results.flatMap(
+            (item) => Array.isArray(item.results) ? item.results : []
+          ),
+          stripNulls
+        );
+        const changes = batch.results.reduce((sum2, item) => {
+          const meta = item?.meta;
+          const n = meta && typeof meta === "object" && typeof meta.changes === "number" ? meta.changes : 0;
+          return sum2 + n;
+        }, 0);
+        const count = rows2.length > 0 ? rows2.length : changes;
+        const mapped2 = mapResult?.(rows2, count) ?? {
+          data: rows2,
+          count
+        };
+        return successResponse(mapped2.data, mapped2.count, batch, batch.bookmark);
+      }
+      const result = await executeD1Query(d1, {
+        query: compiled.sql,
+        params: compiled.params,
+        ...session
+      });
+      if (!result.ok) {
+        return errorResponse(400, "HTTP_ERROR", result.message, endpoint, method);
+      }
+      const rows = maybeStripNullRows(result.rows, stripNulls);
+      const mapped = mapResult?.(rows, result.count) ?? {
+        data: rows,
+        count: result.count
+      };
+      return successResponse(mapped.data, mapped.count, result, result.bookmark);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return errorResponse(500, "UNKNOWN_ERROR", message, endpoint, method);
+    }
+  }
+  return {
+    baseUrl: CLOUDFLARE_EDGE_BASE_URL,
+    buildHeaders(callOptions) {
+      return { ...callOptions?.headers ?? {} };
+    },
+    async resolveCallOptions(callOptions) {
+      return callOptions;
+    },
+    async verifyConnection(connectionOptions) {
+      const baseUrl = CLOUDFLARE_EDGE_BASE_URL;
+      try {
+        const result = await executeD1Query(d1, { query: "SELECT 1 AS ok" });
+        if (!result.ok) {
+          return {
+            ok: false,
+            reachable: false,
+            status: 500,
+            statusText: null,
+            baseUrl,
+            url: `${baseUrl}/d1`,
+            error: result.message,
+            errorDetails: null,
+            raw: result
+          };
+        }
+        return {
+          ok: true,
+          reachable: true,
+          status: 200,
+          statusText: "OK",
+          baseUrl,
+          url: `${baseUrl}/d1`,
+          error: void 0,
+          errorDetails: null,
+          raw: result
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          ok: false,
+          reachable: false,
+          status: 0,
+          statusText: null,
+          baseUrl,
+          url: `${baseUrl}/d1`,
+          error: message,
+          errorDetails: null,
+          raw: null
+        };
+      }
+    },
+    async fetchGateway(payload, callOptions) {
+      try {
+        if (payload && typeof payload === "object" && "operation" in payload) {
+          return errorResponse(
+            400,
+            "HTTP_ERROR",
+            "Direct AST operation payloads are unsupported on D1 edge-local",
+            "/gateway/fetch",
+            "POST"
+          );
+        }
+        const compiled = compileD1Fetch(payload);
+        const stripNulls = resolveStripNulls(payload.strip_nulls, callOptions, true);
+        if (payload.head === true) {
+          return runCompiled(
+            compiled,
+            callOptions,
+            "/gateway/fetch",
+            "POST",
+            (rows) => ({ data: [], count: extractAthenaCount(rows) }),
+            // COUNT rows are meta, not user-facing object rows
+            false
+          );
+        }
+        const wantsTotalCount = payload.count === "exact" || payload.count === "planned" || payload.count === "estimated";
+        if (wantsTotalCount) {
+          const session = sessionFromOptions(callOptions, options);
+          const countCompiled = compileD1Count(payload);
+          const batch = await executeD1Batch(d1, {
+            statements: [
+              {
+                query: compiled.sql,
+                params: compiled.params
+              },
+              {
+                query: countCompiled.sql,
+                params: countCompiled.params
+              }
+            ],
+            ...session
+          });
+          if (!batch.ok) {
+            return errorResponse(400, "HTTP_ERROR", batch.message, "/gateway/fetch", "POST");
+          }
+          const dataItem = batch.results[0];
+          const countItem = batch.results[1];
+          if (!dataItem || dataItem.success === false) {
+            const message = dataItem && typeof dataItem.error === "string" && dataItem.error.trim() ? dataItem.error : "D1 page query failed";
+            return errorResponse(400, "HTTP_ERROR", message, "/gateway/fetch", "POST");
+          }
+          if (!countItem || countItem.success === false) {
+            const message = countItem && typeof countItem.error === "string" && countItem.error.trim() ? countItem.error : "D1 count query failed";
+            return errorResponse(400, "HTTP_ERROR", message, "/gateway/fetch", "POST");
+          }
+          const dataRows = Array.isArray(dataItem.results) ? dataItem.results : [];
+          const countRows = Array.isArray(countItem.results) ? countItem.results : [];
+          const total = extractAthenaCount(countRows);
+          const rows = maybeStripNullRows(dataRows, stripNulls);
+          return successResponse(
+            rows,
+            total,
+            { data: dataItem, count: countItem, batch },
+            batch.bookmark
+          );
+        }
+        return runCompiled(compiled, callOptions, "/gateway/fetch", "POST", void 0, stripNulls);
+      } catch (error) {
+        return compileErrorResponse(error, "/gateway/fetch", "POST");
+      }
+    },
+    async insertGateway(payload, callOptions) {
+      try {
+        const compiled = compileD1Insert(payload);
+        const stripNulls = resolveStripNulls(void 0, callOptions, true);
+        return runCompiled(compiled, callOptions, "/gateway/insert", "PUT", void 0, stripNulls);
+      } catch (error) {
+        return compileErrorResponse(error, "/gateway/insert", "PUT");
+      }
+    },
+    async updateGateway(payload, callOptions) {
+      try {
+        const session = sessionFromOptions(callOptions, options);
+        const compileOptions = await compileOptionsForBoundedMutation(d1, payload, session);
+        const compiled = compileD1Update(payload, compileOptions);
+        const stripNulls = resolveStripNulls(payload.strip_nulls, callOptions, true);
+        return runCompiled(compiled, callOptions, "/gateway/update", "POST", void 0, stripNulls);
+      } catch (error) {
+        return compileErrorResponse(error, "/gateway/update", "POST");
+      }
+    },
+    async deleteGateway(payload, callOptions) {
+      try {
+        const session = sessionFromOptions(callOptions, options);
+        const compileOptions = await compileOptionsForBoundedMutation(d1, payload, session);
+        const compiled = compileD1Delete(payload, compileOptions);
+        const stripNulls = resolveStripNulls(void 0, callOptions, true);
+        return runCompiled(compiled, callOptions, "/gateway/delete", "DELETE", void 0, stripNulls);
+      } catch (error) {
+        return compileErrorResponse(error, "/gateway/delete", "DELETE");
+      }
+    },
+    async rpcGateway(payload, callOptions) {
+      return errorResponse(
+        400,
+        "HTTP_ERROR",
+        "RPC is unsupported on D1 edge-local mode",
+        "/gateway/rpc",
+        "POST",
+        "Use flat CRUD or raw query SQL instead"
+      );
+    },
+    async queryGateway(payload, callOptions) {
+      try {
+        const params = payload.params ?? callOptions?.params;
+        const session = sessionFromOptions(callOptions, options);
+        const query = rewritePostgresSqlForSqlite(payload.query);
+        const result = await executeD1Query(d1, {
+          query,
+          params: Array.isArray(params) ? params : [],
+          ...session
+        });
+        if (!result.ok) {
+          return errorResponse(400, "HTTP_ERROR", result.message, "/gateway/query", "POST");
+        }
+        const stripNulls = resolveStripNulls(void 0, callOptions, true);
+        const rows = maybeStripNullRows(result.rows, stripNulls);
+        return successResponse(
+          rows,
+          result.count,
+          { ...result, query },
+          result.bookmark
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResponse(500, "UNKNOWN_ERROR", message, "/gateway/query", "POST");
+      }
+    }
+  };
+}
+
+// src/config/errors.ts
+var AthenaConfigurationError = class extends Error {
+  code;
+  service;
+  constructor(code, message, service) {
+    super(message);
+    this.name = "AthenaConfigurationError";
+    this.code = code;
+    this.service = service;
+  }
+};
+
+// src/cloudflare/execution-mode.ts
+var ATHENA_EXECUTION_MODE_ENV_KEY = "ATHENA_EXECUTION_MODE";
+var ATHENA_EXECUTION_PREFER_ENV_KEY = "ATHENA_EXECUTION_PREFER";
+var MODE_ALIASES = {
+  gateway: "gateway",
+  server: "gateway",
+  remote: "gateway",
+  http: "gateway",
+  edge: "edge",
+  cloudflare: "edge",
+  "cloudflare-edge": "edge",
+  d1: "edge",
+  local: "edge",
+  auto: "auto"
+};
+function normalizeOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function normalizeModeString(value) {
+  if (value == null) return void 0;
+  const key = value.trim().toLowerCase();
+  if (!key) return void 0;
+  const mapped = MODE_ALIASES[key];
+  if (!mapped) {
+    throw new AthenaConfigurationError(
+      "ATHENA_NO_SERVICE_CONFIGURED",
+      `Unknown Athena execution mode "${value}". Use gateway | edge | auto (aliases: server, remote, cloudflare, d1).`,
+      "db"
+    );
+  }
+  return mapped;
+}
+function isD1Binding(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.prepare === "function"
+  );
+}
+var GATEWAY_URL_ENV_KEYS = [
+  "ATHENA_URL",
+  "NEXT_PUBLIC_ATHENA_URL",
+  "ATHENA_DB_URL",
+  "ATHENA_GATEWAY_URL",
+  "NEXT_PUBLIC_ATHENA_DB_API_URL"
+];
+function resolveGatewayUrl(url, env) {
+  if (normalizeOptional(url)) {
+    return normalizeOptional(url);
+  }
+  for (const key of GATEWAY_URL_ENV_KEYS) {
+    const value = normalizeOptional(env[key]);
+    if (value) return value;
+  }
+  return void 0;
+}
+function resolvePrefer(prefer, env) {
+  const raw = normalizeOptional(typeof prefer === "string" ? prefer : prefer ?? void 0) ?? normalizeOptional(env[ATHENA_EXECUTION_PREFER_ENV_KEY]) ?? "edge";
+  const key = raw.toLowerCase();
+  if (key === "gateway" || key === "server" || key === "remote" || key === "http") {
+    return "gateway";
+  }
+  if (key === "edge" || key === "d1" || key === "cloudflare" || key === "local") {
+    return "edge";
+  }
+  throw new AthenaConfigurationError(
+    "ATHENA_NO_SERVICE_CONFIGURED",
+    `Unknown Athena execution prefer "${raw}". Use edge | gateway.`,
+    "db"
+  );
+}
+function resolveAthenaExecutionMode(input = {}) {
+  const env = input.env ?? {};
+  const fromEnv = normalizeModeString(env[ATHENA_EXECUTION_MODE_ENV_KEY]);
+  const requested = normalizeModeString(input.mode) ?? fromEnv ?? "auto";
+  const url = resolveGatewayUrl(input.url, env);
+  const hasD1 = isD1Binding(input.d1);
+  const hasGateway = Boolean(url);
+  if (requested === "gateway") {
+    if (!hasGateway) {
+      throw new AthenaConfigurationError(
+        "ATHENA_NO_SERVICE_CONFIGURED",
+        'Athena execution mode is "gateway" but no url / ATHENA_URL / ATHENA_DB_URL / ATHENA_GATEWAY_URL was provided.',
+        "db"
+      );
+    }
+    return "gateway";
+  }
+  if (requested === "edge") {
+    if (!hasD1) {
+      throw new AthenaConfigurationError(
+        "ATHENA_NO_SERVICE_CONFIGURED",
+        'Athena execution mode is "edge" but no D1 binding was provided (db.d1 / config.d1 / env.DB).',
+        "db"
+      );
+    }
+    return "edge";
+  }
+  if (hasD1 && hasGateway) {
+    return resolvePrefer(input.prefer, env);
+  }
+  if (hasD1) return "edge";
+  if (hasGateway) return "gateway";
+  throw new AthenaConfigurationError(
+    "ATHENA_NO_SERVICE_CONFIGURED",
+    'Cannot resolve Athena execution mode: provide mode "gateway" with url/key, mode "edge" with d1, or mode "auto" with either a D1 binding or a gateway URL (ATHENA_URL / ATHENA_DB_URL / ATHENA_GATEWAY_URL).',
+    "db"
+  );
+}
+
+// src/cloudflare/r2/storage.ts
+function normalizePrefix(prefix) {
+  if (!prefix?.trim()) return "";
+  const normalized = prefix.replace(/^\/+/, "").replace(/\/?$/, "/");
+  if (normalized.includes("\0")) {
+    throw new Error("storage prefix must not contain null bytes");
+  }
+  if (normalized.split("/").some((segment) => segment === "..")) {
+    throw new Error('storage prefix must not contain ".." path segments');
+  }
+  return normalized;
+}
+function assertSafeObjectKey(key) {
+  if (typeof key !== "string" || !key.trim()) {
+    throw new Error("Object key is required");
+  }
+  if (key.includes("\0")) {
+    throw new Error("Object key must not contain null bytes");
+  }
+  const cleaned = key.replace(/^\/+/, "");
+  if (!cleaned) {
+    throw new Error("Object key is required");
+  }
+  const segments = cleaned.split("/");
+  if (segments.some((segment) => segment === "..")) {
+    throw new Error('Object key must not contain ".." path segments');
+  }
+  return cleaned;
+}
+function joinKey(prefix, key) {
+  return `${prefix}${assertSafeObjectKey(key)}`;
+}
+function toLogicalKey(prefix, physicalKey) {
+  if (!prefix) return physicalKey;
+  if (physicalKey.startsWith(prefix)) {
+    return physicalKey.slice(prefix.length);
+  }
+  return physicalKey;
+}
+function toPhysicalKey(prefix, key) {
+  return joinKey(prefix, key);
+}
+function unsupported(method) {
+  throw new Error(
+    `storage.${method} is not available in Cloudflare edge-local R2 object mode. Only putObject / getObject / deleteObject / listObjects are supported (L3a).`
+  );
+}
+function createCloudflareR2StorageModule(options) {
+  const prefix = normalizePrefix(options.prefix);
+  const { r2 } = options;
+  const putObject = async (input) => {
+    const logical = assertSafeObjectKey(input.key);
+    const physical = toPhysicalKey(prefix, logical);
+    await r2.put(physical, input.body, {
+      httpMetadata: input.contentType ? { contentType: input.contentType } : void 0,
+      customMetadata: input.metadata
+    });
+    return { key: logical };
+  };
+  const getObject = async (input) => {
+    const logical = assertSafeObjectKey(input.key);
+    const physical = toPhysicalKey(prefix, logical);
+    const object = await r2.get(physical);
+    if (!object) return null;
+    return {
+      key: toLogicalKey(prefix, object.key),
+      size: object.size,
+      contentType: object.httpMetadata?.contentType,
+      body: object
+    };
+  };
+  const deleteObject = async (input) => {
+    const logicalKeys = (Array.isArray(input.key) ? input.key : [input.key]).map(
+      (key) => assertSafeObjectKey(key)
+    );
+    const physicalKeys = logicalKeys.map((key) => toPhysicalKey(prefix, key));
+    await r2.delete(physicalKeys.length === 1 ? physicalKeys[0] : physicalKeys);
+    return { deleted: logicalKeys };
+  };
+  const listObjects = async (input) => {
+    const relative = input?.prefix?.trim() ? assertSafeObjectKey(input.prefix) : "";
+    const listPrefix = `${prefix}${relative}`;
+    const listed = await r2.list({
+      prefix: listPrefix || void 0,
+      limit: input?.limit,
+      cursor: input?.cursor
+    });
+    return {
+      objects: listed.objects.map((object) => ({
+        key: toLogicalKey(prefix, object.key),
+        size: object.size,
+        etag: object.etag,
+        uploaded: object.uploaded
+      })),
+      truncated: listed.truncated,
+      cursor: listed.cursor
+    };
+  };
+  const base = {
+    putObject,
+    getObject,
+    deleteObject,
+    listObjects
+  };
+  return new Proxy(base, {
+    get(target, property, receiver) {
+      if (property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      if (typeof property === "string") {
+        return (...args) => {
+          return unsupported(property);
+        };
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/billing/module.ts
+var SDK_NAME5 = "xylex-group/athena-billing";
+var SDK_HEADER_VALUE4 = buildSdkHeaderValue(SDK_NAME5);
+var AthenaBillingError = class extends Error {
+  status;
+  endpoint;
+  method;
+  body;
+  constructor(input) {
+    super(input.message);
+    this.name = "AthenaBillingError";
+    this.status = input.status;
+    this.endpoint = input.endpoint;
+    this.method = input.method;
+    this.body = input.body;
+  }
+};
+var billingSdkManifest = {
+  namespace: "billing",
+  envelopeKind: "athena",
+  methods: [
+    { name: "getCapabilities", method: "GET", path: "/billing/v1/capabilities" },
+    { name: "createCheckout", method: "POST", path: "/billing/v1/checkouts" },
+    { name: "listProducts", method: "GET", path: "/billing/v1/products" },
+    { name: "listPrices", method: "GET", path: "/billing/v1/prices" },
+    { name: "listCustomers", method: "GET", path: "/billing/v1/customers" },
+    { name: "createCustomer", method: "POST", path: "/billing/v1/customers" },
+    { name: "getCustomer", method: "GET", path: "/billing/v1/customers/{id}" },
+    { name: "updateCustomer", method: "PATCH", path: "/billing/v1/customers/{id}" },
+    { name: "deleteCustomer", method: "DELETE", path: "/billing/v1/customers/{id}" },
+    { name: "listPayments", method: "GET", path: "/billing/v1/payments" },
+    { name: "createPayment", method: "POST", path: "/billing/v1/payments" },
+    { name: "getPayment", method: "GET", path: "/billing/v1/payments/{id}" },
+    { name: "cancelPayment", method: "POST", path: "/billing/v1/payments/{id}/cancel" },
+    { name: "listPaymentLinks", method: "GET", path: "/billing/v1/payment-links" },
+    { name: "createPaymentLink", method: "POST", path: "/billing/v1/payment-links" },
+    { name: "getPaymentLink", method: "GET", path: "/billing/v1/payment-links/{id}" },
+    { name: "updatePaymentLink", method: "PATCH", path: "/billing/v1/payment-links/{id}" },
+    { name: "deletePaymentLink", method: "DELETE", path: "/billing/v1/payment-links/{id}" },
+    { name: "listRefunds", method: "GET", path: "/billing/v1/refunds" },
+    { name: "createRefund", method: "POST", path: "/billing/v1/refunds" },
+    { name: "getRefund", method: "GET", path: "/billing/v1/refunds/{id}" },
+    { name: "cancelRefund", method: "POST", path: "/billing/v1/refunds/{id}/cancel" },
+    { name: "listSubscriptions", method: "GET", path: "/billing/v1/subscriptions" },
+    { name: "createSubscription", method: "POST", path: "/billing/v1/subscriptions" },
+    { name: "getSubscription", method: "GET", path: "/billing/v1/subscriptions/{id}" },
+    { name: "updateSubscription", method: "PATCH", path: "/billing/v1/subscriptions/{id}" },
+    { name: "cancelSubscription", method: "POST", path: "/billing/v1/subscriptions/{id}/cancel" },
+    { name: "listInvoices", method: "GET", path: "/billing/v1/invoices" },
+    { name: "getInvoice", method: "GET", path: "/billing/v1/invoices/{id}" },
+    { name: "listWebhooks", method: "GET", path: "/billing/v1/webhooks" },
+    { name: "createWebhook", method: "POST", path: "/billing/v1/webhooks" },
+    { name: "getWebhook", method: "GET", path: "/billing/v1/webhooks/{id}" },
+    { name: "updateWebhook", method: "PATCH", path: "/billing/v1/webhooks/{id}" },
+    { name: "deleteWebhook", method: "DELETE", path: "/billing/v1/webhooks/{id}" },
+    { name: "testWebhook", method: "POST", path: "/billing/v1/webhooks/{id}/test" },
+    {
+      name: "listConnections",
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/connections"
+    },
+    {
+      name: "createConnection",
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/connections"
+    },
+    {
+      name: "getConnection",
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
+    },
+    {
+      name: "updateConnection",
+      method: "PATCH",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
+    },
+    {
+      name: "deleteConnection",
+      method: "DELETE",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}"
+    },
+    {
+      name: "reconcileDocument",
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/connections/{connection_id}/reconcile"
+    },
+    {
+      name: "listWebhookEvents",
+      method: "GET",
+      path: "/admin/billing/clients/{client_name}/webhook-events"
+    },
+    {
+      name: "provisionWebhookSinks",
+      method: "POST",
+      path: "/admin/billing/clients/{client_name}/webhook-sinks/provision"
+    },
+    { name: "listGrants", method: "GET", path: "/admin/billing/grants" },
+    { name: "listProviders", method: "GET", path: "/admin/billing/providers" },
+    {
+      name: "listSinkHelpers",
+      method: "GET",
+      path: "/admin/webhook-sinks/helpers/billing"
+    },
+    {
+      name: "ingestProviderWebhook",
+      method: "POST",
+      path: "/billing/providers/{provider}/clients/{client_name}/connections/{connection_id}/webhook"
+    },
+    { name: "getDebugBilling", method: "GET", path: "/debug/billing" }
+  ]
+};
+function withPathParam2(path, name, value) {
+  return path.replace(`{${name}}`, encodeURIComponent(value));
+}
+function appendQuery3(path, query) {
+  if (!query) return path;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, String(value));
+  }
+  const serialized = params.toString();
+  return serialized ? `${path}?${serialized}` : path;
+}
+function connectionQuery(input) {
+  const query = {
+    connectionId: input.connectionId
+  };
+  if (input.clientName) query.clientName = input.clientName;
+  if ("cursor" in input && input.cursor) query.cursor = input.cursor;
+  if ("source" in input && input.source) query.source = input.source;
+  if ("limit" in input && input.limit !== void 0) query.limit = String(input.limit);
+  if ("offset" in input && input.offset !== void 0) query.offset = String(input.offset);
+  return query;
+}
+function parseEnvelopeData(body) {
+  if (body && typeof body === "object" && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+function createBillingModule(config) {
+  const baseUrl = normalizeAthenaGatewayBaseUrl(config.baseUrl, {
+    label: "Athena billing base URL"
+  });
+  const fetchImpl = config.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  async function call(method, path, body, options, responseType = "json") {
+    const headers = buildAthenaRequestHeaders({
+      profile: "gateway",
+      sdkHeaderValue: SDK_HEADER_VALUE4,
+      apiKey: options?.apiKey ?? config.apiKey,
+      client: config.client,
+      configHeaders: {
+        ...config.headers ?? {}
+      },
+      callHeaders: options?.headers,
+      contentType: "application/json"
+    });
+    let requestBody;
+    if (body !== void 0 && body !== null) {
+      if (typeof body === "string" || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof FormData || body instanceof URLSearchParams) {
+        requestBody = body;
+      } else {
+        requestBody = JSON.stringify(body);
+        if (!hasHeaderIgnoreCase(headers, "Content-Type")) {
+          headers["Content-Type"] = "application/json";
+        }
+      }
+    }
+    const targetUrl = `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    const response = await fetchImpl(targetUrl, {
+      method,
+      headers,
+      body: requestBody,
+      signal: options?.signal
+    });
+    if (responseType === "text") {
+      const text = await response.text();
+      if (!response.ok) {
+        throw new AthenaBillingError({
+          message: `Billing request failed (${response.status})`,
+          status: response.status,
+          endpoint: path,
+          method,
+          body: text
+        });
+      }
+      return text;
+    }
+    const rawText = await response.text();
+    let parsed = rawText;
+    if (rawText) {
+      try {
+        parsed = JSON.parse(rawText);
+      } catch {
+        parsed = rawText;
+      }
+    } else {
+      parsed = null;
     }
     if (!response.ok) {
       const message = parsed && typeof parsed === "object" && "message" in parsed && typeof parsed.message === "string" ? parsed.message : `Billing request failed (${response.status})`;
@@ -10553,18 +13212,6 @@ function createBillingModule(config) {
   };
 }
 
-// src/config/errors.ts
-var AthenaConfigurationError = class extends Error {
-  code;
-  service;
-  constructor(code, message, service) {
-    super(message);
-    this.name = "AthenaConfigurationError";
-    this.code = code;
-    this.service = service;
-  }
-};
-
 // src/context/merge.ts
 function mergeAthenaRequestContexts(base, override) {
   if (!base && !override) return void 0;
@@ -10578,6 +13225,82 @@ function mergeAthenaRequestContexts(base, override) {
   };
 }
 
+// src/diagnostics.ts
+function readProcessEnv2() {
+  try {
+    return globalThis.process?.env ?? {};
+  } catch {
+    return {};
+  }
+}
+function isTruthyEnv(value) {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function isQuietAthenaDiagnosticsEnvironment(env = readProcessEnv2()) {
+  const nodeEnv = env.NODE_ENV?.trim().toLowerCase();
+  if (nodeEnv === "production") {
+    return true;
+  }
+  if (isTruthyEnv(env.OPENNEXT_BUILD)) {
+    return true;
+  }
+  const nextPhase = env.NEXT_PHASE?.trim();
+  if (nextPhase === "phase-production-build") {
+    return true;
+  }
+  if (isTruthyEnv(env.CI) && nodeEnv !== "test") {
+    if (nodeEnv === "production" || isTruthyEnv(env.OPENNEXT_BUILD)) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveBooleanFlag(explicit, mode, quiet) {
+  if (typeof explicit === "boolean") {
+    return explicit;
+  }
+  if (mode === true) {
+    return true;
+  }
+  if (mode === false) {
+    return false;
+  }
+  if (mode === "auto") {
+    return false;
+  }
+  return false;
+}
+function resolveAthenaClientDiagnostics(input) {
+  const env = input.env ?? readProcessEnv2();
+  const quiet = isQuietAthenaDiagnosticsEnvironment(env);
+  const mode = input.diagnostics;
+  const effectiveMode = mode === "auto" && quiet ? false : mode;
+  const debugAst = resolveBooleanFlag(input.debugAst, effectiveMode);
+  const findManyAst = resolveBooleanFlag(input.findManyAst, effectiveMode);
+  let traceQueries;
+  if (input.traceQueries !== void 0) {
+    if (typeof input.traceQueries === "boolean") {
+      traceQueries = input.traceQueries;
+    } else if (effectiveMode === false || mode === "auto" && quiet) {
+      const enabled = input.traceQueries.enabled;
+      traceQueries = typeof enabled === "boolean" ? enabled ? input.traceQueries : false : false;
+    } else {
+      traceQueries = input.traceQueries;
+    }
+  } else if (effectiveMode === true) {
+    traceQueries = true;
+  } else {
+    traceQueries = false;
+  }
+  return {
+    debugAst,
+    findManyAst,
+    traceQueries
+  };
+}
+
 // src/v3-client.ts
 var ENV_URL_KEYS = ["ATHENA_URL", "NEXT_PUBLIC_ATHENA_URL"];
 var ENV_DB_URL_KEYS = ["ATHENA_DB_URL", "ATHENA_GATEWAY_URL", "NEXT_PUBLIC_ATHENA_DB_API_URL"];
@@ -10586,7 +13309,13 @@ var ENV_CHAT_URL_KEYS = ["ATHENA_CHAT_URL", "NEXT_PUBLIC_ATHENA_CHAT_URL"];
 var ENV_CHAT_WS_URL_KEYS = ["ATHENA_CHAT_WS_URL", "NEXT_PUBLIC_ATHENA_CHAT_WS_URL"];
 var ENV_STORAGE_URL_KEYS = ["ATHENA_STORAGE_URL", "NEXT_PUBLIC_ATHENA_STORAGE_URL"];
 var ENV_KEY_KEYS = ["ATHENA_API_KEY", "NEXT_PUBLIC_ATHENA_API_KEY", "ATHENA_GATEWAY_API_KEY", "X_API_KEY"];
-var ENV_CLIENT_KEYS = ["ATHENA_CLIENT", "NEXT_PUBLIC_ATHENA_CLIENT"];
+var ENV_CLIENT_KEYS = [
+  "ATHENA_CLIENT",
+  "ATHENA_GATEWAY_CLIENT",
+  "ATHENA_GENERATOR_CLIENT",
+  "NEXT_PUBLIC_ATHENA_CLIENT",
+  "NEXT_PUBLIC_ATHENA_GATEWAY_CLIENT"
+];
 var MISSING_DB_SENTINEL = "https://athena.invalid/db";
 function readFirstEnv(env, keys) {
   for (const key of keys) {
@@ -10595,14 +13324,30 @@ function readFirstEnv(env, keys) {
   }
   return void 0;
 }
-function normalizeOptional(value) {
+function readFirstEnvHttpUrl(env, keys) {
+  for (const key of keys) {
+    const value = env?.[key]?.trim();
+    if (value && isAbsoluteHttpUrl(value)) return value;
+  }
+  return void 0;
+}
+function normalizeOptional2(value) {
   const normalized = value?.trim();
   return normalized || void 0;
 }
+function isAbsoluteHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
 function appendPath(baseUrl, path) {
   return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
 }
 function toWebSocketUrl(baseUrl) {
+  if (!isAbsoluteHttpUrl(baseUrl)) return void 0;
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.pathname = `${url.pathname.replace(/\/+$/, "")}/wss/gateway`;
@@ -10612,11 +13357,11 @@ function toWebSocketUrl(baseUrl) {
 }
 function resolveCore(config) {
   const env = config.env;
-  const explicitRoot = normalizeOptional(config.url);
-  const envRoot = readFirstEnv(env, ENV_URL_KEYS);
-  const root = explicitRoot ?? envRoot;
-  const explicitRootWinsOverEnvServices = explicitRoot !== void 0;
-  const resolveService = (explicit, envKeys, path) => normalizeOptional(explicit) ?? (explicitRootWinsOverEnvServices && root ? appendPath(root, path) : void 0) ?? readFirstEnv(env, envKeys) ?? (root ? appendPath(root, path) : void 0);
+  const explicitRoot = normalizeOptional2(config.url);
+  const envRoot = readFirstEnvHttpUrl(env, ENV_URL_KEYS);
+  const root = explicitRoot && isAbsoluteHttpUrl(explicitRoot) ? explicitRoot : explicitRoot ? void 0 : envRoot;
+  const explicitRootWinsOverEnvServices = Boolean(root && explicitRoot && isAbsoluteHttpUrl(explicitRoot));
+  const resolveService = (explicit, envKeys, path) => normalizeOptional2(explicit) ?? (explicitRootWinsOverEnvServices && root ? appendPath(root, path) : void 0) ?? readFirstEnvHttpUrl(env, envKeys) ?? (root ? appendPath(root, path) : void 0);
   const dbUrl = resolveService(config.db?.url, ENV_DB_URL_KEYS, "db");
   const urls = {
     db: dbUrl,
@@ -10624,8 +13369,8 @@ function resolveCore(config) {
     chat: resolveService(config.chat?.url, ENV_CHAT_URL_KEYS, "chat"),
     storage: resolveService(config.storage?.url, ENV_STORAGE_URL_KEYS, "storage"),
     // Billing lives on the main Athena HTTP surface (same host as gateway/db).
-    billing: normalizeOptional(config.billing?.url) ?? dbUrl ?? root ?? void 0,
-    chatWs: normalizeOptional(config.chat?.wsUrl) ?? (explicitRootWinsOverEnvServices && root ? toWebSocketUrl(root) : void 0) ?? readFirstEnv(env, ENV_CHAT_WS_URL_KEYS) ?? (root ? toWebSocketUrl(root) : void 0)
+    billing: normalizeOptional2(config.billing?.url) ?? dbUrl ?? root ?? void 0,
+    chatWs: normalizeOptional2(config.chat?.wsUrl) ?? (explicitRootWinsOverEnvServices && root ? toWebSocketUrl(root) : void 0) ?? readFirstEnvHttpUrl(env, ENV_CHAT_WS_URL_KEYS) ?? (root ? toWebSocketUrl(root) : void 0)
   };
   if (!urls.db && !urls.auth && !urls.chat && !urls.storage && !urls.billing) {
     throw new AthenaConfigurationError(
@@ -10634,7 +13379,7 @@ function resolveCore(config) {
       "db"
     );
   }
-  const key = normalizeOptional(config.key) ?? readFirstEnv(env, ENV_KEY_KEYS);
+  const key = normalizeOptional2(config.key) ?? readFirstEnv(env, ENV_KEY_KEYS);
   if (!key) {
     throw new AthenaConfigurationError(
       "ATHENA_API_KEY_REQUIRED",
@@ -10645,7 +13390,7 @@ function resolveCore(config) {
     config,
     urls,
     key,
-    client: normalizeOptional(config.client) ?? readFirstEnv(env, ENV_CLIENT_KEYS)
+    client: normalizeOptional2(config.client) ?? readFirstEnv(env, ENV_CLIENT_KEYS)
   };
   return {
     ...base,
@@ -10660,7 +13405,20 @@ async function resolveConfiguredContext(core, viewContext) {
 function createInternalConfig(core) {
   const { config, urls } = core;
   const { url: _authUrl, ...authOptions } = config.auth ?? {};
-  const { url: _storageUrl, directUpload, ...storageOptions } = config.storage ?? {};
+  const {
+    url: _storageUrl,
+    directUpload,
+    r2: _r2,
+    prefix: _r2Prefix,
+    ...storageOptions
+  } = config.storage ?? {};
+  const diagnostics = resolveAthenaClientDiagnostics({
+    diagnostics: config.diagnostics,
+    debugAst: config.debugAst,
+    findManyAst: config.findManyAst,
+    traceQueries: config.traceQueries,
+    env: config.env
+  });
   return {
     baseUrl: urls.db ?? MISSING_DB_SENTINEL,
     apiKey: core.key,
@@ -10677,14 +13435,15 @@ function createInternalConfig(core) {
     models: config.models,
     behavior: {
       retryReads: config.retryReads,
-      traceQueries: config.traceQueries,
-      debugAst: config.debugAst,
-      findManyAst: config.findManyAst
+      traceQueries: diagnostics.traceQueries,
+      debugAst: diagnostics.debugAst,
+      findManyAst: diagnostics.findManyAst
     },
     storage: {
       ...storageOptions,
       ...directUpload ? { directUpload } : {}
-    }
+    },
+    gatewayTransport: config.gatewayTransport
   };
 }
 function serviceGuard(urls, service) {
@@ -10705,7 +13464,233 @@ function createUnavailableNamespace(service, urls, path = []) {
       serviceGuard(urls, service);
       throw new TypeError(`Athena service property ${path.map(String).join(".")} is not callable.`);
     }
-  });
+  });
+}
+function isD1Binding2(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.prepare === "function"
+  );
+}
+function isR2Binding(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.put === "function" && typeof value.get === "function"
+  );
+}
+function foldBindingAliases(config) {
+  const d1 = config.db?.d1 ?? config.d1;
+  const r2 = config.storage?.r2 ?? config.r2;
+  const sessionMode = config.db?.sessionMode ?? config.sessionMode;
+  const prefix = config.storage?.prefix ?? config.storagePrefix;
+  let next = { ...config };
+  if (d1 !== void 0 || sessionMode !== void 0) {
+    next = {
+      ...next,
+      db: {
+        ...next.db,
+        ...d1 !== void 0 ? { d1 } : {},
+        ...sessionMode !== void 0 ? { sessionMode } : {}
+      }
+    };
+  }
+  if (r2 !== void 0 || prefix !== void 0) {
+    next = {
+      ...next,
+      storage: {
+        ...next.storage,
+        ...r2 !== void 0 ? { r2 } : {},
+        ...prefix !== void 0 ? { prefix } : {}
+      }
+    };
+  }
+  const {
+    d1: _d1,
+    r2: _r2,
+    storagePrefix: _storagePrefix,
+    sessionMode: _sessionMode,
+    ...rest
+  } = next;
+  return rest;
+}
+function applyExecutionMode(config) {
+  const d1 = config.db?.d1;
+  const hasD1 = isD1Binding2(d1);
+  const hasUrl = Boolean(
+    normalizeOptional2(config.url) ?? normalizeOptional2(config.db?.url) ?? (config.env ? normalizeOptional2(config.env.ATHENA_URL) ?? normalizeOptional2(config.env.NEXT_PUBLIC_ATHENA_URL) : void 0)
+  );
+  const hasModeHint = config.mode != null || config.prefer != null || Boolean(config.env?.ATHENA_EXECUTION_MODE) || Boolean(config.env?.ATHENA_EXECUTION_PREFER);
+  if (!hasD1 && !hasModeHint) {
+    return config;
+  }
+  if (hasD1 && !hasUrl && !hasModeHint) {
+    return config;
+  }
+  let resolved;
+  try {
+    resolved = resolveAthenaExecutionMode({
+      mode: config.mode,
+      prefer: config.prefer,
+      d1: hasD1 ? d1 : null,
+      url: config.url ?? config.db?.url,
+      env: config.env
+    });
+  } catch (error) {
+    if (!hasModeHint) return config;
+    throw error;
+  }
+  if (resolved === "gateway" && hasD1) {
+    const { d1: _drop, sessionMode: _sm, ...dbRest } = config.db ?? {};
+    return {
+      ...config,
+      db: Object.keys(dbRest).length > 0 ? dbRest : void 0,
+      gatewayTransport: void 0
+    };
+  }
+  return config;
+}
+function resolveUnifiedRemoteRoot(config) {
+  return normalizeOptional2(config.url) ?? readFirstEnv(config.env, ENV_URL_KEYS);
+}
+function isEdgeLocalSentinelUrl(url) {
+  if (!url) return false;
+  return url === CLOUDFLARE_EDGE_BASE_URL || url.startsWith("https://athena.local/") || url.startsWith("http://athena.local/");
+}
+function hasRemoteDbGatewayUrl(config) {
+  const dbUrl = normalizeOptional2(config.db?.url) ?? readFirstEnv(config.env, ENV_DB_URL_KEYS);
+  return Boolean(dbUrl && !isEdgeLocalSentinelUrl(dbUrl));
+}
+function hasRemoteHttpServices(config) {
+  return Boolean(
+    resolveUnifiedRemoteRoot(config) || hasRemoteDbGatewayUrl(config) || normalizeOptional2(config.auth?.url) || readFirstEnv(config.env, ENV_AUTH_URL_KEYS) || normalizeOptional2(config.storage?.url) || readFirstEnv(config.env, ENV_STORAGE_URL_KEYS) || normalizeOptional2(config.chat?.url) || readFirstEnv(config.env, ENV_CHAT_URL_KEYS) || normalizeOptional2(config.billing?.url)
+  );
+}
+function hasRemoteHttpStorage(config) {
+  return Boolean(
+    normalizeOptional2(config.storage?.url) || readFirstEnv(config.env, ENV_STORAGE_URL_KEYS) || resolveUnifiedRemoteRoot(config)
+  );
+}
+function hasRemoteAuthService(config) {
+  return Boolean(
+    normalizeOptional2(config.auth?.url) || readFirstEnv(config.env, ENV_AUTH_URL_KEYS) || resolveUnifiedRemoteRoot(config)
+  );
+}
+function materializeEdgeBindings(config) {
+  const d1 = config.db?.d1;
+  const r2 = config.storage?.r2;
+  const hasD1 = isD1Binding2(d1);
+  const hasR2 = isR2Binding(r2);
+  if (!hasD1 && !hasR2) {
+    return config;
+  }
+  if (hasD1 && d1 && typeof d1.prepare !== "function") {
+    throw new AthenaConfigurationError(
+      "ATHENA_NO_SERVICE_CONFIGURED",
+      "db.d1 must be a D1 binding with prepare().",
+      "db"
+    );
+  }
+  const remoteRoot = resolveUnifiedRemoteRoot(config);
+  const remoteServices = hasRemoteHttpServices(config);
+  const remoteStorage = hasRemoteHttpStorage(config);
+  const remoteAuth = hasRemoteAuthService(config);
+  const next = { ...config };
+  if (hasD1 && d1) {
+    if (!config.gatewayTransport) {
+      next.gatewayTransport = createCloudflareD1GatewayTransport({
+        d1,
+        defaultSessionMode: config.db?.sessionMode
+      });
+    }
+    const explicitDbUrl = normalizeOptional2(config.db?.url);
+    const remoteDbGateway = hasRemoteDbGatewayUrl(config);
+    next.db = {
+      ...config.db,
+      d1,
+      url: explicitDbUrl ?? (remoteDbGateway ? void 0 : CLOUDFLARE_EDGE_BASE_URL)
+    };
+    const explicitKey = normalizeOptional2(config.key);
+    if (explicitKey) {
+      next.key = explicitKey;
+    } else if (!remoteServices) {
+      next.key = CLOUDFLARE_EDGE_API_KEY;
+    } else {
+      next.key = void 0;
+    }
+    if (remoteRoot) {
+      next.billing = {
+        ...config.billing ?? {},
+        url: normalizeOptional2(config.billing?.url) ?? remoteRoot
+      };
+    }
+    if (!config.capabilities) {
+      next.capabilities = createCloudflareEdgeCapabilities({
+        hasR2,
+        // Explicit storage.url / env storage URL / unified remote root all count.
+        hasRemoteStorage: remoteStorage,
+        authRemote: remoteAuth,
+        findManyAst: false
+      });
+    }
+  } else if (hasR2 && r2) {
+    if (!remoteRoot && !normalizeOptional2(config.db?.url) && !normalizeOptional2(config.storage?.url) && !readFirstEnv(config.env, ENV_STORAGE_URL_KEYS)) {
+      next.storage = {
+        ...config.storage,
+        r2,
+        // Local sentinel so resolveCore accepts a storage-only binding client.
+        url: CLOUDFLARE_EDGE_BASE_URL
+      };
+      if (!remoteServices) {
+        next.key = normalizeOptional2(config.key) ?? CLOUDFLARE_EDGE_API_KEY;
+      } else if (normalizeOptional2(config.key)) {
+        next.key = normalizeOptional2(config.key);
+      } else {
+        next.key = void 0;
+      }
+    }
+    if (!config.capabilities) {
+      if (remoteRoot || normalizeOptional2(config.db?.url) || readFirstEnv(config.env, ENV_DB_URL_KEYS)) {
+        const base = createGatewayCapabilities({
+          authRemote: remoteAuth,
+          storageConfigured: true
+        });
+        next.capabilities = {
+          ...base,
+          storage: {
+            ...base.storage,
+            local: true,
+            objects: true
+          }
+        };
+      } else {
+        next.capabilities = {
+          mode: "cloudflare-edge",
+          db: {
+            engine: "unknown",
+            local: false,
+            layers: {
+              query: false,
+              flatCrud: false,
+              findManyAst: false,
+              rpc: false,
+              relations: false
+            }
+          },
+          storage: {
+            local: true,
+            objects: true,
+            catalogs: false,
+            backups: false
+          },
+          auth: {
+            remote: remoteAuth
+          }
+        };
+      }
+    }
+  }
+  return next;
+}
+function normalizeCreateClientConfig(config) {
+  return materializeEdgeBindings(applyExecutionMode(foldBindingAliases(config)));
 }
 function createClientView(core, viewContext) {
   const resolved = createInternalClientView(
@@ -10724,12 +13709,23 @@ function createClientView(core, viewContext) {
     },
     ...billingOptions
   }) : createUnavailableNamespace("billing", core.urls);
+  const capabilities = core.config.capabilities ?? createGatewayCapabilities({
+    authRemote: Boolean(core.urls.auth),
+    // Match unavailable storage proxy when no storage URL was resolved.
+    storageConfigured: Boolean(core.urls.storage)
+  });
+  const r2 = core.config.storage?.r2;
+  const storageModule = isR2Binding(r2) ? createCloudflareR2StorageModule({
+    r2,
+    prefix: core.config.storage?.prefix ?? void 0
+  }) : core.urls.storage ? resolved.storage : createUnavailableNamespace("storage", core.urls);
   const client = {
     db: core.urls.db ? resolved.db : createUnavailableNamespace("db", core.urls),
     auth: core.urls.auth ? resolved.auth : createUnavailableNamespace("auth", core.urls),
     chat: core.urls.chat ? resolved.chat : createUnavailableNamespace("chat", core.urls),
-    storage: core.urls.storage ? resolved.storage : createUnavailableNamespace("storage", core.urls),
+    storage: storageModule,
     billing: billingModule,
+    capabilities,
     from: ((...args) => {
       requireDb();
       return Reflect.apply(resolved.from, resolved, args);
@@ -10753,13 +13749,34 @@ function createClientView(core, viewContext) {
       return resolved.verifyConnection(options);
     },
     withContext(context) {
+      warnIfEmptyRequestContext(context);
       return createClientView(core, mergeAthenaRequestContexts(viewContext, context));
     }
   };
   return Object.freeze(client);
 }
+function isEmptyAthenaRequestContext(context) {
+  if (!context) return true;
+  const hasHeaders = context.headers != null && Object.keys(context.headers).length > 0;
+  return context.userId == null && context.organizationId == null && !normalizeOptionalContextString(context.cookie) && !normalizeOptionalContextString(context.bearerToken) && !normalizeOptionalContextString(context.sessionToken) && !context.forceNoCache && !hasHeaders;
+}
+function normalizeOptionalContextString(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function warnIfEmptyRequestContext(context) {
+  if (!isEmptyAthenaRequestContext(context)) return;
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  if (nodeEnv === "production") {
+    return;
+  }
+  console.warn(
+    "[athena] withContext({}) has no userId, organizationId, cookie, bearerToken, sessionToken, headers, or forceNoCache. Gateway scope headers will not change. Pass identity fields, or use createAthenaServerClient({ session, scope })."
+  );
+}
 function createClient(config) {
-  return createClientView(resolveCore(config));
+  const normalized = normalizeCreateClientConfig(config);
+  return createClientView(resolveCore(normalized));
 }
 
 // src/gateway/types.ts
@@ -10996,6 +14013,27 @@ function resolveTotalItemsFromPage({
   }
   return clampAthenaReadQueryTotalItems(exactCount, limit);
 }
+function resolveAthenaReadQueryPageFetch({
+  page,
+  pageSize,
+  limit
+}) {
+  const safePage = Math.max(1, Math.trunc(page) || 1);
+  const safePageSize = Math.max(1, Math.trunc(pageSize) || 1);
+  if (!limit || limit < 1) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: true };
+  }
+  const totalCap = Math.trunc(limit);
+  const offset = (safePage - 1) * safePageSize;
+  if (offset >= totalCap) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: false };
+  }
+  return {
+    page: safePage,
+    pageSize: Math.min(safePageSize, totalCap - offset),
+    shouldFetch: true
+  };
+}
 async function executeAthenaReadQuery({
   client,
   page,
@@ -11014,15 +14052,29 @@ async function executeAthenaReadQuery({
     count: "exact",
     head: true
   });
+  const pageFetch = resolveAthenaReadQueryPageFetch({
+    limit: query.limit,
+    page,
+    pageSize
+  });
+  if (!pageFetch.shouldFetch) {
+    return {
+      rows: [],
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count],
+        limit: query.limit,
+        page: pageFetch.page,
+        pageSize,
+        rowCount: 0
+      })
+    };
+  }
   if ((query.mode ?? "findMany") === "select") {
-    const selectBuilder = applyAthenaReadQuerySelectLimit(
-      applyAthenaReadQuerySelectOrder(
-        applyAthenaReadQueryFilters(baseBuilder, query.filters),
-        query.orderBy
-      ),
-      query.limit
+    const selectBuilder = applyAthenaReadQuerySelectOrder(
+      applyAthenaReadQueryFilters(baseBuilder, query.filters),
+      query.orderBy
     );
-    const result2 = await selectBuilder.currentPage(page).pageSize(pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
+    const result2 = await selectBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
       count: "exact"
     });
     const rows2 = flattenAthenaReadQueryRows(
@@ -11036,7 +14088,7 @@ async function executeAthenaReadQuery({
       totalItems: resolveTotalItemsFromPage({
         countCandidates: [countResult.count, result2.count],
         limit: query.limit,
-        page,
+        page: pageFetch.page,
         pageSize,
         rowCount: rows2.length
       })
@@ -11044,12 +14096,11 @@ async function executeAthenaReadQuery({
   }
   const findManyOrderBy = buildAthenaReadQueryFindManyOrderBy(query.orderBy);
   const findManyOptions = {
-    ...query.limit ? { limit: query.limit } : {},
     ...findManyOrderBy ? { orderBy: findManyOrderBy } : {},
     select: buildAthenaReadQueryFindManySelect(query.columns),
     ...query.filters?.length ? { where: buildAthenaReadQueryFindManyWhere(query.filters) } : {}
   };
-  const result = await baseBuilder.currentPage(page).pageSize(pageSize).findMany(findManyOptions);
+  const result = await baseBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).findMany(findManyOptions);
   const rows = flattenAthenaReadQueryRows(
     Array.isArray(result.data) ? result.data : [],
     query.columns,
@@ -11061,7 +14112,7 @@ async function executeAthenaReadQuery({
     totalItems: resolveTotalItemsFromPage({
       countCandidates: [countResult.count, result.count],
       limit: query.limit,
-      page,
+      page: pageFetch.page,
       pageSize,
       rowCount: rows.length
     })
@@ -12056,12 +15107,19 @@ var DIRECT_CONNECTION_STRING_ENV_KEYS = [
 ];
 var POSTGRES_DATABASE_ENV_KEYS = ["ATHENA_GENERATOR_DB", "ATHENA_DATABASE", "PGDATABASE"];
 var POSTGRES_PASSWORD_ENV_KEYS = ["ATHENA_GENERATOR_PG_PASSWORD", "PGPASSWORD"];
-var GATEWAY_URL_ENV_KEYS = ["ATHENA_URL", "ATHENA_GATEWAY_URL", "ATHENA_GENERATOR_URL"];
+var GATEWAY_URL_ENV_KEYS2 = ["ATHENA_URL", "ATHENA_GATEWAY_URL", "ATHENA_GENERATOR_URL"];
 var GATEWAY_API_KEY_ENV_KEYS = [
   "ATHENA_API_KEY",
   "ATHENA_GATEWAY_API_KEY",
   "ATHENA_GENERATOR_API_KEY"
 ];
+var GATEWAY_CLIENT_ENV_KEYS = [
+  "ATHENA_CLIENT",
+  "ATHENA_GATEWAY_CLIENT",
+  "ATHENA_GENERATOR_CLIENT",
+  "NEXT_PUBLIC_ATHENA_CLIENT",
+  "NEXT_PUBLIC_ATHENA_GATEWAY_CLIENT"
+];
 var GENERATOR_SCHEMA_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMAS"];
 var OUTPUT_FORMAT_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_FORMAT"];
 var OUTPUT_PRESET_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_PRESET"];
@@ -12354,7 +15412,7 @@ function normalizeProviderConfig(provider) {
     const gatewayUrl = normalizeRequiredString(
       provider.gatewayUrl,
       "provider.gatewayUrl",
-      GATEWAY_URL_ENV_KEYS
+      GATEWAY_URL_ENV_KEYS2
     );
     const apiKey = normalizeRequiredString(
       provider.apiKey,
@@ -12362,11 +15420,13 @@ function normalizeProviderConfig(provider) {
       GATEWAY_API_KEY_ENV_KEYS
     );
     const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? "postgres";
+    const client = normalizeOptionalString(provider.client, GATEWAY_CLIENT_ENV_KEYS);
     return {
       ...provider,
       gatewayUrl,
       apiKey,
       database,
+      ...client ? { client } : {},
       schemas: normalizeSchemaSelection(provider.schemas)
     };
   }
@@ -12556,10 +15616,11 @@ function buildEnvironmentProviderConfig() {
       schemas: normalizeSchemaSelection(resolveFallbackValue(GENERATOR_SCHEMA_ENV_KEYS))
     };
   }
-  const gatewayUrl = resolveFallbackValue(GATEWAY_URL_ENV_KEYS);
+  const gatewayUrl = resolveFallbackValue(GATEWAY_URL_ENV_KEYS2);
   const apiKey = resolveFallbackValue(GATEWAY_API_KEY_ENV_KEYS);
   if (gatewayUrl && apiKey) {
     const backend = resolveOptionalOneOf(GATEWAY_BACKEND_ENV_KEYS, BACKEND_TYPE_VALUES);
+    const client = resolveFallbackValue(GATEWAY_CLIENT_ENV_KEYS);
     return {
       kind: "postgres",
       mode: "gateway",
@@ -12567,7 +15628,8 @@ function buildEnvironmentProviderConfig() {
       apiKey,
       database: normalizeOptionalString(void 0, POSTGRES_DATABASE_ENV_KEYS),
       schemas: normalizeSchemaSelection(resolveFallbackValue(GENERATOR_SCHEMA_ENV_KEYS)),
-      backend
+      backend,
+      ...client ? { client } : {}
     };
   }
   return void 0;
@@ -12711,6 +15773,8 @@ async function discoverGatewaySchemas(config) {
   const client = createClient({
     db: { url: config.gatewayUrl },
     key: config.apiKey,
+    client: config.client,
+    env: typeof process !== "undefined" ? process.env : void 0,
     backend: {
       type: config.backend ?? "postgresql"
     }
@@ -12797,6 +15861,7 @@ function buildGatewayProviderBlock(schemas) {
     mode: "gateway",
     gatewayUrl: generatorEnv("ATHENA_URL"),
     apiKey: generatorEnv("ATHENA_API_KEY"),
+    client: generatorEnv("ATHENA_CLIENT", { optional: true }),
     database: generatorEnv("ATHENA_GENERATOR_DB", { default: "postgres" }),
     schemas: ${formatStringArray(schemas, "    ")},
   }`;
@@ -13820,7 +16885,7 @@ function renderModelArtifact(descriptor, config) {
   const relationsAssignment = config.features.emitRelations && relationEntries.length > 0 ? `
 Object.assign(${descriptor.tableConstName}.meta, {
   relations: {
-${relationEntries.map(([relationKey2, relationValue]) => `    ${renderObjectKey(relationKey2)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
+${relationEntries.map(([relationKey3, relationValue]) => `    ${renderObjectKey(relationKey3)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
   }
 })
 ` : "";
@@ -13897,7 +16962,7 @@ function renderModelArtifact2(databaseName, descriptor, config) {
   const relationEntries = Object.entries(descriptor.table.relations);
   const relationBlock = config.features.emitRelations && relationEntries.length > 0 ? `,
     relations: {
-${relationEntries.map(([relationKey2, relationValue]) => `      ${renderObjectKey(relationKey2)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
+${relationEntries.map(([relationKey3, relationValue]) => `      ${renderObjectKey(relationKey3)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
     }` : "";
   const content = `import { defineModel } from '@xylex-group/athena'
 
@@ -14004,8 +17069,14 @@ var AthenaGatewayPostgresIntrospectionProvider = class {
   constructor(config) {
     this.config = config;
     this.client = createClient({
+      url: this.config.gatewayUrl,
       db: { url: this.config.gatewayUrl },
       key: this.config.apiKey,
+      // Multi-tenant gateways reject DEFAULT_CLIENT; prefer explicit config.
+      // Also pass process.env so ATHENA_CLIENT / ATHENA_GATEWAY_CLIENT still resolve
+      // when the field was not normalized into provider config.
+      client: this.config.client,
+      env: typeof process !== "undefined" ? process.env : void 0,
       backend: {
         type: this.config.backend ?? "postgresql"
       }
@@ -15486,12 +18557,439 @@ async function ensureActiveOrganization(options) {
   }
 }
 
+// src/tables/catalog.ts
+var POSTGRES_CATALOG_SQL2 = {
+  columns: `
+    SELECT
+      n.nspname AS schema_name,
+      c.relname AS table_name,
+      a.attname AS column_name,
+      format_type(a.atttypid, a.atttypmod) AS data_type,
+      NOT a.attnotnull AS is_nullable
+    FROM pg_attribute a
+    JOIN pg_class c ON c.oid = a.attrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE c.relkind IN ('r', 'p')
+      AND a.attnum > 0
+      AND NOT a.attisdropped
+      AND n.nspname = ANY($1::text[])
+    ORDER BY n.nspname, c.relname, a.attnum;
+  `,
+  foreignKeys: `
+    SELECT
+      sn.nspname AS source_schema,
+      sc.relname AS source_table,
+      con.conname AS constraint_name,
+      ARRAY_AGG(sa.attname ORDER BY cols.ordinality) AS source_columns,
+      tn.nspname AS target_schema,
+      tc.relname AS target_table,
+      ARRAY_AGG(ta.attname ORDER BY cols.ordinality) AS target_columns,
+      EXISTS (
+        SELECT 1
+        FROM pg_constraint uq
+        WHERE uq.conrelid = con.conrelid
+          AND uq.contype IN ('p', 'u')
+          AND uq.conkey = con.conkey
+      ) AS source_is_unique
+    FROM pg_constraint con
+    JOIN pg_class sc ON sc.oid = con.conrelid
+    JOIN pg_namespace sn ON sn.oid = sc.relnamespace
+    JOIN pg_class tc ON tc.oid = con.confrelid
+    JOIN pg_namespace tn ON tn.oid = tc.relnamespace
+    JOIN unnest(con.conkey, con.confkey) WITH ORDINALITY AS cols(source_attnum, target_attnum, ordinality) ON TRUE
+    JOIN pg_attribute sa ON sa.attrelid = con.conrelid AND sa.attnum = cols.source_attnum
+    JOIN pg_attribute ta ON ta.attrelid = con.confrelid AND ta.attnum = cols.target_attnum
+    WHERE con.contype = 'f'
+      AND sn.nspname = ANY($1::text[])
+      AND tn.nspname = ANY($1::text[])
+    GROUP BY
+      sn.nspname,
+      sc.relname,
+      con.conname,
+      tn.nspname,
+      tc.relname,
+      con.conkey,
+      con.conrelid
+    ORDER BY sn.nspname, sc.relname, con.conname;
+  `,
+  primaryKeys: `
+    SELECT
+      n.nspname AS schema_name,
+      c.relname AS table_name,
+      ARRAY_AGG(a.attname ORDER BY ck.ordinality) AS columns
+    FROM pg_constraint con
+    JOIN pg_class c ON c.oid = con.conrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    JOIN unnest(con.conkey) WITH ORDINALITY AS ck(attnum, ordinality) ON TRUE
+    JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ck.attnum
+    WHERE con.contype = 'p'
+      AND n.nspname = ANY($1::text[])
+    GROUP BY n.nspname, c.relname
+    ORDER BY n.nspname, c.relname;
+  `
+};
+function parseAthenaTableSchemaScope(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(
+    (entry, index, values) => entry.length > 0 && values.indexOf(entry) === index
+  );
+}
+function escapeSqlLiteral2(value) {
+  return value.replace(/'/g, "''");
+}
+function buildSchemaArrayLiteral2(schemas) {
+  const literals = schemas.map((schema) => `'${escapeSqlLiteral2(schema)}'`).join(", ");
+  return `ARRAY[${literals}]`;
+}
+function inlineSchemaLiteral2(sql, schemas) {
+  return sql.replace(
+    /\$1::text\[\]/g,
+    `${buildSchemaArrayLiteral2(schemas)}::text[]`
+  );
+}
+function buildAthenaTableCatalogQueries(schemas) {
+  return {
+    columns: inlineSchemaLiteral2(POSTGRES_CATALOG_SQL2.columns, schemas),
+    foreignKeys: inlineSchemaLiteral2(POSTGRES_CATALOG_SQL2.foreignKeys, schemas),
+    primaryKeys: inlineSchemaLiteral2(POSTGRES_CATALOG_SQL2.primaryKeys, schemas)
+  };
+}
+function tableKey2(schema, table2) {
+  return `${schema}.${table2}`;
+}
+function relationKey2(...parts) {
+  const base = parts.join("_").replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+  return base.length > 0 ? base : "relation";
+}
+function parsePostgresArrayLiteral2(text) {
+  const body = text.slice(1, -1).trim();
+  if (!body) {
+    return [];
+  }
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  let escaped = false;
+  for (const char of body) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values.map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function coerceStringArray2(value) {
+  if (value == null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry.trim()).filter(Boolean);
+  }
+  if (typeof value !== "string") {
+    return [];
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    return [];
+  }
+  if (trimmedValue.startsWith("{") && trimmedValue.endsWith("}")) {
+    return parsePostgresArrayLiteral2(trimmedValue);
+  }
+  return trimmedValue.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function createTableCatalog() {
+  const tables = /* @__PURE__ */ new Map();
+  const ensureTable = (schema, name) => {
+    const id = tableKey2(schema, name);
+    const existingTable = tables.get(id);
+    if (existingTable) {
+      return existingTable;
+    }
+    const nextTable = {
+      columns: [],
+      id,
+      name,
+      primaryKey: [],
+      relationMap: /* @__PURE__ */ new Map(),
+      schema
+    };
+    tables.set(id, nextTable);
+    return nextTable;
+  };
+  const upsertRelation = (table2, key, relation) => {
+    table2.relationMap.set(key, relation);
+  };
+  return {
+    addColumnRows(columnRows) {
+      for (const row of columnRows) {
+        const table2 = ensureTable(row.schema_name, row.table_name);
+        table2.columns.push({
+          dataType: row.data_type,
+          isNullable: row.is_nullable,
+          isPrimaryKey: false,
+          name: row.column_name
+        });
+      }
+    },
+    addForeignKeyRows(foreignKeyRows) {
+      for (const row of foreignKeyRows) {
+        const sourceTable = ensureTable(row.source_schema, row.source_table);
+        const targetTable = ensureTable(row.target_schema, row.target_table);
+        upsertRelation(
+          sourceTable,
+          relationKey2(row.constraint_name, row.target_table),
+          {
+            name: row.constraint_name,
+            targetSchema: row.target_schema,
+            targetTable: row.target_table
+          }
+        );
+        upsertRelation(targetTable, relationKey2(row.source_table), {
+          name: relationKey2(row.source_table, row.constraint_name),
+          targetSchema: row.source_schema,
+          targetTable: row.source_table
+        });
+      }
+    },
+    addManyToManyRows(foreignKeyRows) {
+      const foreignKeysBySourceTable = /* @__PURE__ */ new Map();
+      for (const foreignKey of foreignKeyRows) {
+        const key = tableKey2(foreignKey.source_schema, foreignKey.source_table);
+        const current = foreignKeysBySourceTable.get(key) ?? {
+          foreignKeys: [],
+          schema: foreignKey.source_schema,
+          table: foreignKey.source_table
+        };
+        current.foreignKeys.push(foreignKey);
+        foreignKeysBySourceTable.set(key, current);
+      }
+      for (const candidate of foreignKeysBySourceTable.values()) {
+        const bridgeTable = tables.get(
+          tableKey2(candidate.schema, candidate.table)
+        );
+        if (!bridgeTable || candidate.foreignKeys.length !== 2) {
+          continue;
+        }
+        const combinedForeignColumns = Array.from(
+          new Set(
+            candidate.foreignKeys.flatMap(
+              (foreignKey) => coerceStringArray2(foreignKey.source_columns)
+            )
+          )
+        );
+        if (bridgeTable.primaryKey.length === 0 || combinedForeignColumns.length !== bridgeTable.primaryKey.length || !bridgeTable.primaryKey.every(
+          (column) => combinedForeignColumns.includes(column)
+        )) {
+          continue;
+        }
+        const [firstForeignKey, secondForeignKey] = candidate.foreignKeys;
+        const firstTarget = tables.get(
+          tableKey2(firstForeignKey.target_schema, firstForeignKey.target_table)
+        );
+        const secondTarget = tables.get(
+          tableKey2(
+            secondForeignKey.target_schema,
+            secondForeignKey.target_table
+          )
+        );
+        if (!(firstTarget && secondTarget)) {
+          continue;
+        }
+        upsertRelation(
+          firstTarget,
+          relationKey2(candidate.table, secondForeignKey.target_table),
+          {
+            name: relationKey2(
+              candidate.table,
+              secondForeignKey.constraint_name
+            ),
+            targetSchema: secondForeignKey.target_schema,
+            targetTable: secondForeignKey.target_table
+          }
+        );
+        upsertRelation(
+          secondTarget,
+          relationKey2(candidate.table, firstForeignKey.target_table),
+          {
+            name: relationKey2(candidate.table, firstForeignKey.constraint_name),
+            targetSchema: firstForeignKey.target_schema,
+            targetTable: firstForeignKey.target_table
+          }
+        );
+      }
+    },
+    addPrimaryKeyRows(primaryKeyRows) {
+      for (const row of primaryKeyRows) {
+        const table2 = ensureTable(row.schema_name, row.table_name);
+        const primaryKey = coerceStringArray2(row.columns);
+        table2.primaryKey = primaryKey;
+        for (const columnName of primaryKey) {
+          const column = table2.columns.find(
+            (candidate) => candidate.name === columnName
+          );
+          if (column) {
+            column.isPrimaryKey = true;
+          }
+        }
+      }
+    },
+    toResponse(database) {
+      return {
+        database,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tables: [...tables.values()].map((table2) => ({
+          columns: [...table2.columns].sort(
+            (left, right) => left.name.localeCompare(right.name)
+          ),
+          id: table2.id,
+          name: table2.name,
+          primaryKey: [...table2.primaryKey],
+          relations: [...table2.relationMap.values()].map((relation) => ({
+            columns: tables.get(
+              tableKey2(relation.targetSchema, relation.targetTable)
+            )?.columns ?? [],
+            name: relation.name,
+            targetSchema: relation.targetSchema,
+            targetTable: relation.targetTable
+          })).sort(
+            (left, right) => left.name.localeCompare(right.name)
+          ),
+          schema: table2.schema
+        })).sort(
+          (left, right) => left.id.localeCompare(right.id)
+        )
+      };
+    }
+  };
+}
+async function queryRows(client, query) {
+  const result = await client.query(query);
+  if (result.error || result.status < 200 || result.status >= 300) {
+    const errorMessage = typeof result.error === "string" ? result.error : result.error && typeof result.error === "object" && "message" in result.error && typeof result.error.message === "string" ? result.error.message : `Athena gateway query failed with status ${result.status}.`;
+    throw new Error(errorMessage);
+  }
+  return Array.isArray(result.data) ? result.data : [];
+}
+function isAthenaTableSchemaConfig(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const config = value;
+  return typeof config.gatewayUrl === "string" && typeof config.gatewayKey === "string" && typeof config.gatewayDatabase === "string" && typeof config.schemaScope === "string" && typeof config.clientName === "string";
+}
+function hasAthenaTableSchemaCredentials(config) {
+  return config.gatewayUrl.trim().length > 0 && config.gatewayKey.trim().length > 0 && config.gatewayDatabase.trim().length > 0;
+}
+async function fetchAthenaTableCatalog(config, options = {}) {
+  const schemas = parseAthenaTableSchemaScope(config.schemaScope);
+  if (schemas.length === 0) {
+    return {
+      database: config.gatewayDatabase,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tables: []
+    };
+  }
+  const queries = buildAthenaTableCatalogQueries(schemas);
+  const client = options.client ?? createClient({
+    url: config.gatewayUrl.trim(),
+    key: config.gatewayKey.trim(),
+    client: config.clientName.trim() || void 0
+  });
+  const [columnRows, primaryKeyRows, foreignKeyRows] = await Promise.all([
+    queryRows(client, queries.columns),
+    queryRows(client, queries.primaryKeys),
+    queryRows(client, queries.foreignKeys)
+  ]);
+  const catalog = createTableCatalog();
+  catalog.addColumnRows(columnRows);
+  catalog.addPrimaryKeyRows(primaryKeyRows);
+  catalog.addForeignKeyRows(foreignKeyRows);
+  catalog.addManyToManyRows(foreignKeyRows);
+  return catalog.toResponse(config.gatewayDatabase);
+}
+var fetchTableCatalog = fetchAthenaTableCatalog;
+
+// src/tables/schema-handlers.ts
+var ATHENA_TABLE_SCHEMA_ROUTE = "/api/tables/schema";
+function json2(body, init) {
+  const headers = new Headers(init?.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(body), {
+    status: init?.status ?? 200,
+    headers
+  });
+}
+async function handleAthenaTableSchemaPost(request2, options) {
+  const payload = await request2.json().catch(() => null);
+  let config = isAthenaTableSchemaConfig(
+    payload?.config
+  ) ? payload.config : null;
+  if (config && options?.resolveConfig) {
+    config = await options.resolveConfig(config, request2);
+  }
+  if (!config || !isAthenaTableSchemaConfig(config)) {
+    return json2(
+      {
+        error: "The Athena tables showcase config is invalid."
+      },
+      { status: 400 }
+    );
+  }
+  if (!hasAthenaTableSchemaCredentials(config)) {
+    return json2(
+      {
+        error: "Gateway URL, API key, and database are required for schema introspection."
+      },
+      { status: 400 }
+    );
+  }
+  try {
+    const response = await fetchAthenaTableCatalog(
+      config,
+      {
+        client: options?.client
+      }
+    );
+    return json2(response);
+  } catch (error) {
+    return json2(
+      {
+        error: error instanceof Error ? error.message : "Athena schema introspection failed."
+      },
+      { status: 500 }
+    );
+  }
+}
+function createAthenaTableSchemaHandlers(options) {
+  return {
+    POST: (request2) => handleAthenaTableSchemaPost(request2, options)
+  };
+}
+
 exports.ATHENA_AUTH_ADMIN_LIMITS = ATHENA_AUTH_ADMIN_LIMITS;
 exports.ATHENA_AUTH_BASE_ERROR_CODES = ATHENA_AUTH_BASE_ERROR_CODES;
 exports.ATHENA_AUTH_MAX_ADMIN_JSON_BYTES = ATHENA_AUTH_MAX_ADMIN_JSON_BYTES;
 exports.ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH = ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = ATHENA_AUTH_MAX_TEMPLATE_VARIABLES;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH;
+exports.ATHENA_TABLE_SCHEMA_ROUTE = ATHENA_TABLE_SCHEMA_ROUTE;
 exports.AthenaBillingError = AthenaBillingError;
 exports.AthenaChatError = AthenaChatError;
 exports.AthenaConfigurationError = AthenaConfigurationError;
@@ -15520,6 +19018,7 @@ exports.buildAthenaReadQueryFindManyOrderBy = buildAthenaReadQueryFindManyOrderB
 exports.buildAthenaReadQueryFindManySelect = buildAthenaReadQueryFindManySelect;
 exports.buildAthenaReadQueryFindManyWhere = buildAthenaReadQueryFindManyWhere;
 exports.buildAthenaReadQuerySelectString = buildAthenaReadQuerySelectString;
+exports.buildAthenaTableCatalogQueries = buildAthenaTableCatalogQueries;
 exports.buildAthenaTableFindManyOrderBy = buildAthenaTableFindManyOrderBy;
 exports.buildAthenaTableFindManySelect = buildAthenaTableFindManySelect;
 exports.buildAthenaTableFindManyWhere = buildAthenaTableFindManyWhere;
@@ -15529,6 +19028,7 @@ exports.clampAthenaReadQueryTotalItems = clampAthenaReadQueryTotalItems;
 exports.clampAthenaTableTotalItems = clampAthenaTableTotalItems;
 exports.coerceInt = coerceInt;
 exports.createAthenaStorageError = createAthenaStorageError;
+exports.createAthenaTableSchemaHandlers = createAthenaTableSchemaHandlers;
 exports.createAuthReactEmailInput = createAuthReactEmailInput;
 exports.createBillingModule = createBillingModule;
 exports.createClient = createClient;
@@ -15549,6 +19049,8 @@ exports.ensureGeneratorConfigFile = ensureGeneratorConfigFile;
 exports.enumeration = enumeration;
 exports.executeAthenaReadQuery = executeAthenaReadQuery;
 exports.executeAthenaTableQuery = executeAthenaTableQuery;
+exports.fetchAthenaTableCatalog = fetchAthenaTableCatalog;
+exports.fetchTableCatalog = fetchTableCatalog;
 exports.filterIntrospectionSnapshot = filterIntrospectionSnapshot;
 exports.findGeneratorConfigPath = findGeneratorConfigPath;
 exports.flattenAthenaReadQueryRows = flattenAthenaReadQueryRows;
@@ -15556,8 +19058,11 @@ exports.flattenAthenaRows = flattenAthenaRows;
 exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
 exports.generatorEnv = generatorEnv;
 exports.getAthenaDebugAst = getAthenaDebugAst;
+exports.handleAthenaTableSchemaPost = handleAthenaTableSchemaPost;
+exports.hasAthenaTableSchemaCredentials = hasAthenaTableSchemaCredentials;
 exports.identifier = identifier;
 exports.isAthenaGatewayError = isAthenaGatewayError;
+exports.isAthenaTableSchemaConfig = isAthenaTableSchemaConfig;
 exports.isOk = isOk;
 exports.json = json;
 exports.loadGeneratorConfig = loadGeneratorConfig;
@@ -15571,12 +19076,15 @@ exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
 exports.normalizeTableSelection = normalizeTableSelection;
 exports.number = number;
+exports.parseAthenaTableSchemaScope = parseAthenaTableSchemaScope;
 exports.parseBooleanFlag = parseBooleanFlag2;
 exports.patchSchemasInConfigSource = patchSchemasInConfigSource;
 exports.renderAthenaReactEmail = renderAthenaReactEmail;
 exports.renderGeneratorConfigFile = renderGeneratorConfigFile;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
+exports.resolveAthenaExecutionMode = resolveAthenaExecutionMode;
+exports.resolveAthenaReadQueryPageFetch = resolveAthenaReadQueryPageFetch;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;
 exports.resolvePostgresColumnType = resolvePostgresColumnType;
 exports.resolveProviderSchemas = resolveProviderSchemas;