@xylex-group/athena 3.3.0 → 3.5.1

package/dist/next/client.js

@@ -1617,6 +1617,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
   });
@@ -1639,6 +1641,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
   });
@@ -1782,7 +1786,7 @@ function buildAthenaGatewayUrl(baseUrl, path) {
 
 // package.json
 var package_default = {
-  version: "3.3.0"
+  version: "3.5.1"
 };
 
 // src/sdk-version.ts
@@ -4981,9 +4985,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;
@@ -8608,6 +8612,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;
@@ -8662,6 +8668,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;
@@ -8713,7 +8721,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,
@@ -8762,7 +8774,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,
@@ -8814,107 +8826,2745 @@ function createInternalClientView(core, resolveContext) {
           "from(model) does not accept a schema override because the model already defines its target."
         );
       }
-      return createTableBuilder(
-        resolveAthenaModelTargetTableName(tableOrModel),
-        gateway,
-        formatGatewayResult,
-        queryTracer,
-        config.behavior
-      );
+      return createTableBuilder(
+        resolveAthenaModelTargetTableName(tableOrModel),
+        gateway,
+        formatGatewayResult,
+        queryTracer,
+        config.behavior
+      );
+    }
+    const resolvedTableName = resolveTableNameForCall(tableOrModel, options?.schema);
+    return createTableBuilder(
+      resolvedTableName,
+      gateway,
+      formatGatewayResult,
+      queryTracer,
+      config.behavior
+    );
+  }
+  const rpc = (fn, args, options) => {
+    const normalizedFn = fn.trim();
+    if (!normalizedFn) {
+      throw new Error("rpc requires a function name");
+    }
+    return createRpcBuilder(
+      normalizedFn,
+      args,
+      options,
+      gateway,
+      formatGatewayResult,
+      queryTracer,
+      captureTraceCallsite(queryTracer),
+      Boolean(config.behavior?.debugAst)
+    );
+  };
+  const query = createQueryBuilder(
+    gateway,
+    formatGatewayResult,
+    config.behavior,
+    queryTracer
+  );
+  const untypedDbFrom = from;
+  const db = {
+    from,
+    select(table, first, second) {
+      if (first && typeof first === "object" && !Array.isArray(first)) {
+        return untypedDbFrom(table).select(void 0, first);
+      }
+      return untypedDbFrom(table).select(first, second);
+    },
+    insert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).insert(values, options) : untypedDbFrom(table).insert(values, options);
+    },
+    upsert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).upsert(values, options) : untypedDbFrom(table).upsert(values, options);
+    },
+    update(table, values, options) {
+      return untypedDbFrom(table).update(values, options);
+    },
+    delete(table, options) {
+      return untypedDbFrom(table).delete(options);
+    },
+    rpc,
+    query
+  };
+  const chat = createChatModule({
+    baseUrl: config.chatUrl,
+    apiKey: config.apiKey,
+    client: config.client ?? void 0,
+    headers: config.headers,
+    wsUrl: config.chatWsUrl,
+    webSocketFactory: config.chat?.webSocketFactory ?? void 0
+  }, {
+    async resolveCallOptions() {
+      const context = await resolveContext();
+      return context ? {
+        headers: buildContextHeaders(context),
+        bearerToken: context.bearerToken,
+        cookie: context.cookie,
+        sessionToken: context.sessionToken,
+        forceNoCache: context.forceNoCache
+      } : void 0;
+    }
+  });
+  const request2 = createAthenaRequest(config, resolveContext);
+  const storage = createStorageModule(gateway, {
+    ...config.storage,
+    ...config.storageUrl ? {
+      baseUrl: config.storageUrl,
+      stripBasePath: true
+    } : {}
+  });
+  return {
+    from,
+    db,
+    rpc,
+    query,
+    request: request2,
+    verifyConnection: gateway.verifyConnection,
+    auth: auth.auth,
+    chat,
+    storage
+  };
+}
+
+// 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
+      }
+    },
+    storage: {
+      local: false,
+      objects: storageConfigured,
+      catalogs: storageConfigured ? options?.storageCatalogs ?? true : false,
+      backups: storageConfigured ? options?.storageBackups ?? true : false
+    },
+    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
+      }
+    },
+    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
+    },
+    auth: {
+      remote: options.authRemote
+    }
+  };
+}
+
+// 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 isIdentChar(ch) {
+  if (!ch) return false;
+  return /[A-Za-z0-9_]/.test(ch);
+}
+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;
+  }
+}
+function sqlContainsKeywordOutsideLiterals(sql, keyword) {
+  const target = keyword.toUpperCase();
+  let found = false;
+  scanSqlKeywordsOutsideLiterals(sql, (token) => {
+    if (token.toUpperCase() === target) {
+      found = true;
+      return true;
+    }
+    return false;
+  });
+  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;
+    }
+    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 === ")") {
+      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(table, 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(table)}`,
+    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 table = payload.table_name?.trim();
+  if (!table) {
+    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(table, where);
+  }
+  const parts = [
+    `SELECT ${selectClause(columns)} FROM ${quoteIdent(table)}`,
+    where.sql,
+    orderClause(payload.sort_by),
+    limitOffsetClause(payload)
+  ].filter(Boolean);
+  return asSingle(parts.join(" "), where.params);
+}
+function compileD1Count(payload) {
+  rejectStructuredRelations(payload);
+  const table = payload.table_name?.trim();
+  if (!table) {
+    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(table, where);
+}
+function compileD1CountFromWhere(table, where) {
+  const parts = [
+    `SELECT COUNT(*) AS __athena_count FROM ${quoteIdent(table)}`,
+    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(table, 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(table)} 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(table)} (${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 table = payload.table_name?.trim();
+  if (!table) {
+    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(table, {}, 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(table, row, payload))
+    );
+  }
+  if (isSparse && !forceNullForMissing && rows.length === 1) {
+    const compiled = compileSingleRowInsert(table, 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(table)} (${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 table = payload.table_name?.trim();
+  if (!table) {
+    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(
+      table,
+      where.sql,
+      where.params,
+      {
+        ...payload,
+        conditions: payload.conditions
+      },
+      options
+    );
+    params.push(...bounded.params);
+    const parts2 = [
+      `UPDATE ${quoteIdent(table)} 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(table)} SET ${assignments.join(", ")}`,
+    where.sql
+  ];
+  if (wantsReturning(payload)) {
+    parts.push(`RETURNING ${selectClause(payload.columns)}`);
+  }
+  return asSingle(parts.join(" "), params);
+}
+function compileD1Delete(payload, options) {
+  const table = payload.table_name?.trim();
+  if (!table) {
+    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(
+      table,
+      where.sql,
+      where.params,
+      {
+        ...payload,
+        conditions
+      },
+      options
+    );
+    const parts2 = [`DELETE FROM ${quoteIdent(table)}`, `WHERE ${bounded.sql}`];
+    if (wantsReturning(payload)) {
+      parts2.push(`RETURNING ${selectClause(payload.columns)}`);
+    }
+    return asSingle(parts2.join(" "), bounded.params);
+  }
+  const parts = [`DELETE FROM ${quoteIdent(table)}`, 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, table, 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: [table],
+    ...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 table = tableName.trim();
+  if (!table) {
+    throw new D1SqlCompileError("missing_table", "table_name is required for bounded mutation");
+  }
+  const safe = table.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 "${table}" 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: [table],
+      ...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,
+          table,
+          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,
+          table,
+          safe,
+          indexSafe,
+          identity,
+          session
+        );
+        if (!collMatch) {
+          continue;
+        }
+        return identity;
+      }
+    }
+  }
+  throw new D1SqlCompileError(
+    "bounded_mutation_no_unique_identity",
+    `Bounded update/delete on "${table}" 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");
+      }
     }
-    const resolvedTableName = resolveTableNameForCall(tableOrModel, options?.schema);
-    return createTableBuilder(
-      resolvedTableName,
-      gateway,
-      formatGatewayResult,
-      queryTracer,
-      config.behavior
+  };
+}
+
+// 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"
     );
   }
-  const rpc = (fn, args, options) => {
-    const normalizedFn = fn.trim();
-    if (!normalizedFn) {
-      throw new Error("rpc requires a function name");
+  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 createRpcBuilder(
-      normalizedFn,
-      args,
-      options,
-      gateway,
-      formatGatewayResult,
-      queryTracer,
-      captureTraceCallsite(queryTracer),
-      Boolean(config.behavior?.debugAst)
+    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 query = createQueryBuilder(
-    gateway,
-    formatGatewayResult,
-    config.behavior,
-    queryTracer
-  );
-  const untypedDbFrom = from;
-  const db = {
-    from,
-    select(table, first, second) {
-      if (first && typeof first === "object" && !Array.isArray(first)) {
-        return untypedDbFrom(table).select(void 0, first);
+  const base = {
+    putObject,
+    getObject,
+    deleteObject,
+    listObjects
+  };
+  return new Proxy(base, {
+    get(target, property, receiver) {
+      if (property in target) {
+        return Reflect.get(target, property, receiver);
       }
-      return untypedDbFrom(table).select(first, second);
-    },
-    insert(table, values, options) {
-      return Array.isArray(values) ? untypedDbFrom(table).insert(values, options) : untypedDbFrom(table).insert(values, options);
-    },
-    upsert(table, values, options) {
-      return Array.isArray(values) ? untypedDbFrom(table).upsert(values, options) : untypedDbFrom(table).upsert(values, options);
-    },
-    update(table, values, options) {
-      return untypedDbFrom(table).update(values, options);
-    },
-    delete(table, options) {
-      return untypedDbFrom(table).delete(options);
-    },
-    rpc,
-    query
-  };
-  const chat = createChatModule({
-    baseUrl: config.chatUrl,
-    apiKey: config.apiKey,
-    client: config.client ?? void 0,
-    headers: config.headers,
-    wsUrl: config.chatWsUrl,
-    webSocketFactory: config.chat?.webSocketFactory ?? void 0
-  }, {
-    async resolveCallOptions() {
-      const context = await resolveContext();
-      return context ? {
-        headers: buildContextHeaders(context),
-        bearerToken: context.bearerToken,
-        cookie: context.cookie,
-        sessionToken: context.sessionToken,
-        forceNoCache: context.forceNoCache
-      } : void 0;
+      if (typeof property === "string") {
+        return (...args) => {
+          return unsupported(property);
+        };
+      }
+      return void 0;
     }
   });
-  const request2 = createAthenaRequest(config, resolveContext);
-  const storage = createStorageModule(gateway, {
-    ...config.storage,
-    ...config.storageUrl ? {
-      baseUrl: config.storageUrl,
-      stripBasePath: true
-    } : {}
-  });
-  return {
-    from,
-    db,
-    rpc,
-    query,
-    request: request2,
-    verifyConnection: gateway.verifyConnection,
-    auth: auth.auth,
-    chat,
-    storage
-  };
 }
 
 // src/billing/module.ts
@@ -9513,18 +12163,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;
@@ -9637,14 +12275,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`;
@@ -9654,11 +12308,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,
@@ -9666,8 +12320,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(
@@ -9676,7 +12330,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",
@@ -9687,7 +12341,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,
@@ -9702,7 +12356,13 @@ 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,
@@ -9733,7 +12393,8 @@ function createInternalConfig(core) {
     storage: {
       ...storageOptions,
       ...directUpload ? { directUpload } : {}
-    }
+    },
+    gatewayTransport: config.gatewayTransport
   };
 }
 function serviceGuard(urls, service) {
@@ -9756,6 +12417,232 @@ function createUnavailableNamespace(service, urls, path = []) {
     }
   });
 }
+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(
     core.internalCore,
@@ -9773,12 +12660,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);
@@ -9819,7 +12717,8 @@ function normalizeOptionalContextString(value) {
 }
 function warnIfEmptyRequestContext(context) {
   if (!isEmptyAthenaRequestContext(context)) return;
-  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") {
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  if (nodeEnv === "production") {
     return;
   }
   console.warn(
@@ -9827,7 +12726,8 @@ function warnIfEmptyRequestContext(context) {
   );
 }
 function createClient(config) {
-  return createClientView(resolveCore(config));
+  const normalized = normalizeCreateClientConfig(config);
+  return createClientView(resolveCore(normalized));
 }
 
 // src/next/session-bridge/constants.ts