@dee-wan/cache 1.1.0 → 2.0.0

package/dist/chunk-WJNCFFF3.js

@@ -0,0 +1,637 @@
+import { CacheUnavailableError } from './chunk-M4UOCIDQ.js';
+import { parseD1Bookmarks, D1_BOOKMARK_HEADER, serializeD1Bookmarks, decodeD1Bookmarks, mergeD1Bookmarks } from './chunk-ZBYAKDNZ.js';
+import { boundedD1Store } from './chunk-WKZ7TKGM.js';
+import { isD1BindingName } from './chunk-AENVFT2S.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+// src/d1/adapter.ts
+var fence = ["g"];
+var lexemes = /\s+|--[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|'(?:[^']|'')*'?|`(?:[^`]|``)*`?|"(?:[^"]|"")*"?|\[[^\]]*\]?|[A-Za-z_][A-Za-z0-9_$]*|[\s\S]/g;
+var safePragmas = /* @__PURE__ */ new Set(["database_list", "table_list", "table_info", "table_xinfo", "index_list", "index_info", "index_xinfo", "foreign_key_list"]);
+function operationOf(tokens, start = 0) {
+  const word = (index2) => tokens[index2]?.toLowerCase();
+  if (word(start) !== "with") return word(start);
+  let index = start + 1;
+  if (word(index) === "recursive") index++;
+  const group = () => {
+    if (tokens[index] !== "(") return false;
+    let depth = 0;
+    do {
+      if (tokens[index] === "(") depth++;
+      if (tokens[index] === ")") depth--;
+      index++;
+    } while (index < tokens.length && depth > 0);
+    return depth === 0;
+  };
+  while (index < tokens.length) {
+    if (!/^(?:[A-Za-z_][A-Za-z0-9_$]*|`[^`]+`|"[^"]+"|\[[^\]]+\])$/.test(tokens[index] ?? "")) return void 0;
+    index++;
+    if (tokens[index] === "(" && !group()) return void 0;
+    if (word(index++) !== "as") return void 0;
+    if (word(index) === "not") index++;
+    if (word(index) === "materialized") index++;
+    if (tokens[index] !== "(" || !["select", "with"].includes(word(index + 1) ?? "")) return void 0;
+    if (!group()) return void 0;
+    if (tokens[index] !== ",") return word(index);
+    index++;
+  }
+  return void 0;
+}
+function isReadonly(sql) {
+  const tokens = [...sql.matchAll(lexemes)].map(([token = ""]) => token).filter((token) => !/^(?:\s|--|\/\*)/.test(token));
+  if (tokens.at(-1) === ";") tokens.pop();
+  const first = tokens[0]?.toLowerCase();
+  const pragmaName = first === "pragma" ? (tokens[2] === "." ? tokens[3] : tokens[1])?.toLowerCase() : void 0;
+  const readonlyPragma = first === "pragma" && pragmaName !== void 0 && safePragmas.has(pragmaName) && !tokens.includes("=");
+  return !tokens.includes(";") && (operationOf(tokens) === "select" || readonlyPragma);
+}
+function needsWriteFence(sql, unrelatedWrites) {
+  const tokens = [...sql.matchAll(lexemes)].map(([token = ""]) => token).filter((token) => !/^(?:\s|--|\/\*)/.test(token));
+  if (tokens.at(-1) === ";") tokens.pop();
+  if (tokens.includes(";")) return true;
+  let index = 0;
+  const word = () => tokens[index]?.toLowerCase();
+  const operation = word();
+  if (operation !== "insert" && operation !== "update" && operation !== "delete") return true;
+  index++;
+  if ((operation === "insert" || operation === "update") && word() === "or") {
+    index++;
+    if (!["rollback", "abort", "replace", "fail", "ignore"].includes(word() ?? "")) return true;
+    index++;
+  }
+  if (operation === "insert") {
+    if (word() !== "into") return true;
+    index++;
+  }
+  if (operation === "delete") {
+    if (word() !== "from") return true;
+    index++;
+  }
+  const identifier = (token) => {
+    if (!token) return null;
+    if (/^[A-Za-z_][A-Za-z0-9_$]*$/.test(token)) return token.toLowerCase();
+    if (/^"[A-Za-z_][A-Za-z0-9_$]*"$/.test(token) || /^`[A-Za-z_][A-Za-z0-9_$]*`$/.test(token) || /^\[[A-Za-z_][A-Za-z0-9_$]*\]$/.test(token)) return token.slice(1, -1).toLowerCase();
+    return null;
+  };
+  let target = identifier(tokens[index++]);
+  if (tokens[index] === ".") {
+    if (target !== "main") return true;
+    index++;
+    target = identifier(tokens[index++]);
+  }
+  if (!target || !unrelatedWrites.has(target)) return true;
+  if (operation === "update" && word() !== "set") return true;
+  if (operation === "delete" && !["where", "returning"].includes(word() ?? "") && index !== tokens.length) return true;
+  return false;
+}
+function fenceD1Writes(db, options) {
+  const { generation, policy } = options;
+  const store = boundedD1Store(options.store);
+  const unrelatedWrites = new Set(policy.unfencedWriteTables.map((name) => name.toLowerCase()));
+  if (!generation) throw new TypeError("cache generation is required");
+  const statements = /* @__PURE__ */ new WeakMap();
+  const withWrite = async (operation) => {
+    const token = crypto.randomUUID();
+    try {
+      await store.beginWrite({ fences: fence, generation, leaseMs: 6e5, token });
+    } catch (error) {
+      await store.endWrite({ fences: fence, token }).catch(() => void 0);
+      throw new CacheUnavailableError(error);
+    }
+    try {
+      return await operation();
+    } finally {
+      await store.endWrite({ fences: fence, token }).catch(() => void 0);
+    }
+  };
+  const wrapStatement = (raw, sql) => {
+    const requiresFence = !isReadonly(sql) && needsWriteFence(sql, unrelatedWrites);
+    const execute = (operation) => requiresFence ? withWrite(operation) : operation();
+    function rawRows(rawOptions) {
+      return execute(() => rawOptions?.columnNames === true ? raw.raw({ columnNames: true }) : raw.raw(rawOptions?.columnNames === false ? { columnNames: false } : void 0));
+    }
+    const wrapped = {
+      bind: (...next) => wrapStatement(raw.bind(...next), sql),
+      first: (column) => execute(() => column === void 0 ? raw.first() : raw.first(column)),
+      all: () => execute(() => raw.all()),
+      run: () => execute(() => raw.run()),
+      raw: rawRows
+    };
+    statements.set(wrapped, { raw, fence: requiresFence });
+    return wrapped;
+  };
+  const batch = (target, items) => {
+    const resolved = items.map((item) => statements.get(item));
+    const raw = items.map((item, index) => resolved[index]?.raw ?? item);
+    const operation = () => target.batch(raw);
+    return resolved.every((item) => item !== void 0 && !item.fence) ? operation() : withWrite(operation);
+  };
+  return {
+    prepare: (sql) => wrapStatement(db.prepare(sql), sql),
+    batch: (items) => batch(db, items),
+    exec: (sql) => isReadonly(sql) || !needsWriteFence(sql, unrelatedWrites) ? db.exec(sql) : withWrite(() => db.exec(sql)),
+    dump: () => db.dump(),
+    withSession: (constraint) => {
+      const session = db.withSession(constraint);
+      return {
+        prepare: (sql) => wrapStatement(session.prepare(sql), sql),
+        batch: (items) => batch(session, items),
+        getBookmark: () => session.getBookmark()
+      };
+    }
+  };
+}
+
+// src/d1/request-freshness.ts
+var validFreshnessHeader = (name) => /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name);
+var hasFreshnessCookie = (request, name) => (request.headers.get("cookie") ?? "").split(";").some((part) => part.split("=", 1)[0]?.trim() === name);
+var hasFreshnessGeneration = (request, name) => {
+  const matches = (request.headers.get("cookie") ?? "").split(";").map((part) => part.trim()).filter((part) => part.split("=", 1)[0]?.trim() === name);
+  const value = matches[0]?.slice(matches[0].indexOf("=") + 1).trim() ?? "";
+  return matches.length === 1 && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+};
+var hasCacheBypass = (request) => (request.headers.get("cache-control") ?? "").split(",").some((part) => /^\s*(?:no-cache|no-store)(?:\s*=|\s*$)/i.test(part));
+function regionalD1MetadataTtl(request, policy) {
+  if (request.method !== "GET" || hasFreshnessCookie(request, policy.freshnessCookie)) return 0;
+  if (policy.freshnessHeader !== void 0 && (!validFreshnessHeader(policy.freshnessHeader) || request.headers.has(policy.freshnessHeader))) return 0;
+  if (!policy.ignoreRequestCacheControl && hasCacheBypass(request)) return 0;
+  return 5e3;
+}
+var storage = new AsyncLocalStorage();
+var tracking = new AsyncLocalStorage();
+var primarySource = new AsyncLocalStorage();
+var admissionScope = new AsyncLocalStorage();
+var prismaScope = new AsyncLocalStorage();
+var trackerGroups = /* @__PURE__ */ new WeakMap();
+var ambiguousTrackers = /* @__PURE__ */ new WeakSet();
+var infos = /* @__PURE__ */ new WeakMap();
+var facades = /* @__PURE__ */ new WeakMap();
+var queues = /* @__PURE__ */ new Map();
+var admitted = /* @__PURE__ */ new Map();
+var prismaFacades = /* @__PURE__ */ new WeakMap();
+function registerD1SessionAlias(alias, original) {
+  const info = infos.get(original);
+  if (info) infos.set(alias, info);
+}
+function runPrimaryD1SessionSource(operation) {
+  return storage.getStore() ? primarySource.run(/* @__PURE__ */ new Set(), operation) : operation();
+}
+function runD1PrismaScope(operation) {
+  return prismaScope.run({}, operation);
+}
+function addTracker(group, tracker) {
+  if (tracker) {
+    group.trackers.set(tracker, (group.trackers.get(tracker) ?? 0) + 1);
+    if (group.ambiguous) ambiguousTrackers.add(tracker);
+  }
+}
+function removeTracker(group, tracker) {
+  if (!tracker) return;
+  const count = group.trackers.get(tracker) ?? 0;
+  if (count <= 1) group.trackers.delete(tracker);
+  else group.trackers.set(tracker, count - 1);
+}
+async function runD1SessionOperation(database, operation) {
+  const info = infos.get(database);
+  const current = storage.getStore();
+  const context = current && !current.closed ? current : void 0;
+  if (!info) return operation();
+  const token = context ?? prismaScope.getStore();
+  let gate = queues.get(info.id);
+  if (!gate) {
+    gate = { waiting: [] };
+    queues.set(info.id, gate);
+  }
+  const scope = gate;
+  const active = scope.active;
+  const tail = scope.waiting.at(-1);
+  const group = token && tail?.token === token ? tail : token && !tail && active?.token === token ? active : { token, context, pending: 0, waiting: [], tracker: {}, trackers: /* @__PURE__ */ new Map(), ambiguous: false };
+  const startGroup = (next) => {
+    scope.active = next;
+    admitted.set(info.id, next);
+    trackerGroups.set(next.tracker, next);
+    for (const start of next.waiting.splice(0)) start();
+  };
+  let timer;
+  try {
+    await new Promise((resolve, reject) => {
+      let cancelled = false;
+      const start = () => {
+        if (cancelled) return;
+        if (group.pending > 0) {
+          group.ambiguous = true;
+          for (const tracker2 of group.trackers.keys()) ambiguousTrackers.add(tracker2);
+        }
+        group.pending++;
+        resolve();
+      };
+      if (group === active) start();
+      else {
+        group.waiting.push(start);
+        if (group !== tail) {
+          if (!active) startGroup(group);
+          else scope.waiting.push(group);
+        }
+      }
+      if (!group.pending) timer = setTimeout(() => {
+        cancelled = true;
+        const index = group.waiting.indexOf(start);
+        if (index >= 0) group.waiting.splice(index, 1);
+        if (!group.pending && !group.waiting.length) {
+          const position = scope.waiting.indexOf(group);
+          if (position >= 0) scope.waiting.splice(position, 1);
+        }
+        reject(new Error("D1 Prisma admission timed out"));
+      }, 3e4);
+    });
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+  const tracker = tracking.getStore();
+  const primary = primarySource.getStore();
+  if (primary && !group.primary) group.primary = primary;
+  addTracker(group, tracker);
+  try {
+    return await admissionScope.run({ group, tracker }, operation);
+  } finally {
+    removeTracker(group, tracker);
+    group.pending--;
+    if (!group.pending) {
+      const next = scope.waiting.shift();
+      if (next) startGroup(next);
+      else {
+        scope.active = void 0;
+        admitted.delete(info.id);
+        queues.delete(info.id);
+      }
+    }
+  }
+}
+function prismaD1SessionDatabase(database) {
+  const existing = prismaFacades.get(database);
+  if (existing) return existing;
+  const info = infos.get(database);
+  if (!info) return database;
+  const invoke = (operation) => {
+    const admission = admitted.get(info.id);
+    return storage.run(admission?.context, () => admission ? tracking.run(admission.tracker, () => admission.primary ? primarySource.run(admission.primary, operation) : operation()) : operation());
+  };
+  const statements = /* @__PURE__ */ new WeakMap();
+  const wrapStatement = (statement) => {
+    function raw(options) {
+      return invoke(() => options?.columnNames ? statement.raw({ columnNames: true }) : statement.raw());
+    }
+    const wrapped2 = {
+      bind: (...values) => invoke(() => wrapStatement(statement.bind(...values))),
+      first: (column) => invoke(() => column === void 0 ? statement.first() : statement.first(column)),
+      all: () => invoke(() => statement.all()),
+      run: () => invoke(() => statement.run()),
+      raw
+    };
+    statements.set(wrapped2, statement);
+    return wrapped2;
+  };
+  const wrapSession = (session) => ({
+    prepare: (sql) => invoke(() => wrapStatement(session.prepare(sql))),
+    batch: (items) => invoke(() => session.batch(items.map((item) => statements.get(item) ?? item))),
+    getBookmark: () => invoke(() => session.getBookmark())
+  });
+  const wrapped = {
+    prepare: (sql) => invoke(() => wrapStatement(database.prepare(sql))),
+    batch: (items) => invoke(() => database.batch(items.map((item) => statements.get(item) ?? item))),
+    withSession: (constraint) => invoke(() => wrapSession(database.withSession(constraint))),
+    exec: (sql) => invoke(() => database.exec(sql)),
+    dump: () => invoke(() => database.dump())
+  };
+  infos.set(wrapped, info);
+  prismaFacades.set(database, wrapped);
+  return wrapped;
+}
+function contextFor() {
+  const context = storage.getStore();
+  return context && !context.closed ? context : void 0;
+}
+function sessionFor(info, context, write) {
+  let session = context.sessions.get(info.id);
+  const primary = primarySource.getStore();
+  const reanchor = !!primary && !primary.has(info.id);
+  if (reanchor) {
+    primary.add(info.id);
+    session = void 0;
+  }
+  if (!session) {
+    session = info.db.withSession(reanchor || write || info.primary || context.primary || context.primaryIds.has(info.id) ? "first-primary" : context.input[info.id] ?? "first-unconstrained");
+    context.sessions.set(info.id, session);
+  }
+  return session;
+}
+function capture(info, context, session) {
+  const bookmark = session.getBookmark();
+  if (bookmark && !context.closed) {
+    const combined = { ...context.input };
+    if (!mergeD1Bookmarks(combined, context.bookmarks) || !mergeD1Bookmarks(combined, { [info.id]: bookmark })) throw new RangeError("D1 bookmark capacity exceeded");
+    mergeD1Bookmarks(context.bookmarks, { [info.id]: bookmark });
+    const tracker = tracking.getStore();
+    if (tracker) {
+      mergeD1Bookmarks(tracker, { [info.id]: bookmark });
+      const group = trackerGroups.get(tracker);
+      if (group) for (const target of group.trackers.keys()) mergeD1Bookmarks(target, { [info.id]: bookmark });
+    }
+  }
+}
+function runIsolatedD1Session(request, operation) {
+  const parent = storage.getStore();
+  if (!parent) return operation();
+  const input = Object.fromEntries(Object.entries(parseD1Bookmarks(request.headers.get(D1_BOOKMARK_HEADER))).filter(([id]) => parent.allowedIds.has(id)));
+  const context = { input, sessions: /* @__PURE__ */ new Map(), bookmarks: {}, primaryIds: /* @__PURE__ */ new Set(), allowedIds: parent.allowedIds, operations: /* @__PURE__ */ new Map(), primary: false, closed: false };
+  return storage.run(context, () => tracking.run({}, async () => {
+    try {
+      return await operation();
+    } finally {
+      context.closed = true;
+    }
+  }));
+}
+function d1SessionWarmupRequest(request, response) {
+  const bookmarks = responseD1SessionBookmarks(response.headers, tracking.getStore() ?? d1SessionBookmarks());
+  if (!bookmarks) return request;
+  const headers = new Headers(request.headers);
+  const encoded = serializeD1Bookmarks(bookmarks);
+  if (encoded) headers.set(D1_BOOKMARK_HEADER, encoded);
+  return new Request(request, { headers });
+}
+function d1SessionBookmarkFloor() {
+  const context = storage.getStore();
+  return context && !context.closed ? { ...context.input } : void 0;
+}
+function d1SessionBookmarks() {
+  const context = storage.getStore();
+  return context && !context.closed ? { ...context.bookmarks } : void 0;
+}
+function varyD1Bookmarks(headers) {
+  const vary = headers.get("vary");
+  const names = vary ? vary.split(",").map((name) => name.trim()).filter(Boolean) : [];
+  if (!names.some((name) => name === "*" || name.toLowerCase() === D1_BOOKMARK_HEADER.toLowerCase())) headers.set("vary", [...names, D1_BOOKMARK_HEADER].join(", "));
+}
+function responseD1SessionBookmarks(headers, source) {
+  const context = storage.getStore();
+  if (!context || context.closed) return void 0;
+  const result = { ...context.input };
+  const upstream = decodeD1Bookmarks(headers.get(D1_BOOKMARK_HEADER));
+  if (upstream && !mergeD1Bookmarks(result, Object.fromEntries(Object.entries(upstream).filter(([id]) => context.allowedIds.has(id))))) throw new RangeError("D1 bookmark capacity exceeded");
+  if (source && !mergeD1Bookmarks(result, source)) throw new RangeError("D1 bookmark capacity exceeded");
+  return result;
+}
+function d1SessionResponseBookmarks() {
+  const context = storage.getStore();
+  if (!context || context.closed) return void 0;
+  const result = { ...context.input };
+  mergeD1Bookmarks(result, tracking.getStore() ?? context.bookmarks);
+  return result;
+}
+function advanceD1SessionBookmarks(bookmarks) {
+  const context = storage.getStore();
+  if (context && !context.closed) {
+    const filtered = Object.fromEntries(Object.entries(bookmarks).filter(([id]) => context.allowedIds.has(id)));
+    const combined = { ...context.input };
+    if (!mergeD1Bookmarks(combined, context.bookmarks) || !mergeD1Bookmarks(combined, filtered)) throw new RangeError("D1 bookmark capacity exceeded");
+    mergeD1Bookmarks(context.bookmarks, filtered);
+    const tracker = tracking.getStore();
+    if (tracker) mergeD1Bookmarks(tracker, filtered);
+  }
+}
+async function trackD1SessionSource(operation) {
+  const context = storage.getStore();
+  if (!context || context.closed) return { value: await operation() };
+  const parent = tracking.getStore();
+  const tracker = {};
+  const admission = admissionScope.getStore();
+  const previous = admission?.tracker;
+  if (admission) {
+    removeTracker(admission.group, previous);
+    admission.tracker = tracker;
+    addTracker(admission.group, tracker);
+  }
+  try {
+    const value = await tracking.run(tracker, operation);
+    if (parent) mergeD1Bookmarks(parent, tracker);
+    return { value, bookmarks: tracker };
+  } finally {
+    if (admission) {
+      removeTracker(admission.group, tracker);
+      admission.tracker = previous;
+      addTracker(admission.group, previous);
+    }
+  }
+}
+async function serialSession(context, id, operation) {
+  const previous = context.operations.get(id) ?? Promise.resolve();
+  let release;
+  const next = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => next);
+  context.operations.set(id, tail);
+  await previous;
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (context.operations.get(id) === tail) context.operations.delete(id);
+  }
+}
+function wrapD1SessionCacheValue(value, source) {
+  const bookmarks = source ?? tracking.getStore() ?? d1SessionBookmarks();
+  if (bookmarks && (ambiguousTrackers.has(bookmarks) || admissionScope.getStore()?.group.ambiguous)) return { d1SessionCache: 0 };
+  return bookmarks ? { d1SessionCache: 1, bookmarks, value } : value;
+}
+function unwrapD1SessionCacheValue(value, databaseIds) {
+  const floor = d1SessionBookmarkFloor();
+  if (!floor) return { value };
+  if (!value || typeof value !== "object" || Reflect.get(value, "d1SessionCache") !== 1 || !Reflect.has(value, "value")) return null;
+  const raw = Reflect.get(value, "bookmarks");
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const serialized = JSON.stringify(raw);
+  const bookmarks = parseD1Bookmarks(serialized);
+  if (Object.keys(bookmarks).length !== Object.keys(raw).length) return null;
+  if (databaseIds.some((id) => floor[id] !== void 0 && (!bookmarks[id] || bookmarks[id] < floor[id]))) return null;
+  return { value: Reflect.get(value, "value"), bookmarks };
+}
+function d1SessionCacheHooks(database) {
+  return {
+    key: () => d1SessionBookmarkFloor() ? "d1-session-v1" : null,
+    read(value) {
+      const info = infos.get(database);
+      if (d1SessionBookmarkFloor() && !info) return null;
+      const cached = unwrapD1SessionCacheValue(value, info ? [info.id] : []);
+      if (d1SessionBookmarkFloor() && info && !cached?.bookmarks?.[info.id]) return null;
+      if (cached?.bookmarks) advanceD1SessionBookmarks(cached.bookmarks);
+      return cached;
+    },
+    background(operation) {
+      const bookmarks = d1SessionResponseBookmarks();
+      if (!bookmarks) return operation();
+      const encoded = serializeD1Bookmarks(bookmarks);
+      const request = new Request("https://d1-session.invalid/", { headers: encoded ? { [D1_BOOKMARK_HEADER]: encoded } : {} });
+      return runIsolatedD1Session(request, operation);
+    },
+    async fill(load) {
+      const tracked = await trackD1SessionSource(() => runPrimaryD1SessionSource(load));
+      const active = d1SessionBookmarkFloor();
+      const info = infos.get(database);
+      const cached = active && (!info || !tracked.bookmarks?.[info.id]) ? { d1SessionCache: 0 } : wrapD1SessionCacheValue(tracked.value, tracked.bookmarks);
+      return { value: tracked.value, cached };
+    }
+  };
+}
+function facade(info) {
+  const statements = /* @__PURE__ */ new WeakMap();
+  const prepare = (sql, values = []) => {
+    const execute = async (action) => {
+      const context = contextFor();
+      if (!context) return action(info.db.prepare(sql).bind(...values));
+      return serialSession(context, info.id, async () => {
+        const session = sessionFor(info, context, !isReadonly(sql));
+        const result2 = await action(session.prepare(sql).bind(...values));
+        capture(info, context, session);
+        return result2;
+      });
+    };
+    function raw(options) {
+      return execute((statement) => options?.columnNames ? statement.raw({ columnNames: true }) : statement.raw());
+    }
+    const result = {
+      bind: (...next) => prepare(sql, next),
+      first: (column) => execute((statement) => column === void 0 ? statement.first() : statement.first(column)),
+      run: () => execute((statement) => statement.run()),
+      all: () => execute((statement) => statement.all()),
+      raw
+    };
+    statements.set(result, { sql, values });
+    return result;
+  };
+  const batch = async (items) => {
+    const definitions = items.map((item) => statements.get(item));
+    const context = contextFor();
+    if (!context) return info.db.batch(items.map((item, index) => {
+      const definition = definitions[index];
+      return definition ? info.db.prepare(definition.sql).bind(...definition.values) : item;
+    }));
+    if (definitions.some((item) => !item)) throw new TypeError("D1 batch statements must use the same database facade");
+    const execute = async (target, session) => {
+      const raw = definitions.map((item) => {
+        if (!item) throw new TypeError("Invalid D1 statement");
+        return target.prepare(item.sql).bind(...item.values);
+      });
+      const result = await target.batch(raw);
+      if (session && context) capture(info, context, session);
+      return result;
+    };
+    return serialSession(context, info.id, () => {
+      const session = sessionFor(info, context, definitions.some((item) => item && !isReadonly(item.sql)));
+      return execute(session, session);
+    });
+  };
+  const database = {
+    prepare,
+    batch,
+    exec: async (sql) => {
+      const context = contextFor();
+      if (!context) return info.db.exec(sql);
+      return serialSession(context, info.id, async () => {
+        const result = await info.db.exec(sql);
+        const session = info.db.withSession("first-primary");
+        await session.prepare("SELECT 1").first();
+        context.sessions.set(info.id, session);
+        capture(info, context, session);
+        return result;
+      });
+    },
+    dump: () => info.db.dump(),
+    withSession: (constraint) => {
+      const context = contextFor();
+      if (!context) return info.db.withSession(constraint);
+      if (constraint && constraint !== "first-unconstrained" && constraint !== context.input[info.id]) {
+        if (constraint === "first-primary" && (!context.sessions.has(info.id) || context.primary || info.primary || context.primaryIds.has(info.id))) {
+          context.primaryIds.add(info.id);
+          return { prepare, batch, getBookmark: () => context.sessions.get(info.id)?.getBookmark() ?? null };
+        }
+        throw new Error("Explicit D1 session constraint conflicts with request session");
+      }
+      return { prepare, batch, getBookmark: () => context.sessions.get(info.id)?.getBookmark() ?? null };
+    }
+  };
+  infos.set(database, info);
+  return database;
+}
+function sessionD1Env(env, options) {
+  const raw = Reflect.get(env, options.databaseIdsEnv);
+  if (raw === void 0) return env;
+  let parsed;
+  try {
+    parsed = typeof raw === "string" ? JSON.parse(raw) : null;
+  } catch {
+    parsed = null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Invalid ${options.databaseIdsEnv}`);
+  const ids = Object.fromEntries(Object.entries(parsed).map(([name, id]) => {
+    if (!isD1BindingName(name, { ...options, envPrefix: "", coordinatorNamePrefix: "", coordinatorClass: "", readModels: [], unfencedWriteTables: [] }) || typeof id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) throw new Error("Invalid D1 database identity");
+    return [name, id.toLowerCase()];
+  }));
+  const primaryIds = new Set((options.primaryBindings ?? []).map((name) => ids[name]).filter((id) => typeof id === "string"));
+  const scoped = { ...env };
+  for (const name of options.bindingNames) if (!Reflect.has(env, name)) throw new Error(`Missing D1 binding: ${name}`);
+  for (const [name, db] of Object.entries(env)) {
+    if (options.bindingPrefixes.some((prefix) => name.startsWith(prefix)) && !isD1BindingName(name, { ...options, envPrefix: "", coordinatorNamePrefix: "", coordinatorClass: "", readModels: [], unfencedWriteTables: [] })) throw new Error(`Invalid D1 binding: ${name}`);
+    if (!isD1BindingName(name, { ...options, envPrefix: "", coordinatorNamePrefix: "", coordinatorClass: "", readModels: [], unfencedWriteTables: [] })) continue;
+    const id = ids[name];
+    if (!id || !db || typeof db !== "object" || typeof Reflect.get(db, "withSession") !== "function") throw new Error(`Missing D1 identity or binding: ${name}`);
+    const primary = primaryIds.has(id);
+    let variants = facades.get(db);
+    if (!variants) {
+      variants = /* @__PURE__ */ new Map();
+      facades.set(db, variants);
+    }
+    const key = `${id}:${primary}`;
+    let wrapped = variants.get(key);
+    if (!wrapped) {
+      wrapped = facade({ id, db, primary });
+      variants.set(key, wrapped);
+    }
+    Reflect.set(scoped, name, wrapped);
+  }
+  return scoped;
+}
+function wrapD1ReadSessionHandler(handler, options) {
+  return async (request, env, context) => {
+    if (request.headers.get("upgrade")?.toLowerCase() === "websocket") return handler(request, env, context);
+    if (Reflect.get(env, options.databaseIdsEnv) === void 0) return handler(request, env, context);
+    const scoped = sessionD1Env(env, options);
+    const decoded = decodeD1Bookmarks(request.headers.get(D1_BOOKMARK_HEADER));
+    if (!decoded) return new Response("Invalid D1 bookmarks", { status: 400 });
+    const configured = new Set(Object.entries(scoped).flatMap(([name, value]) => isD1BindingName(name, { ...options, envPrefix: "", coordinatorNamePrefix: "", coordinatorClass: "", readModels: [], unfencedWriteTables: [] }) && value && typeof value === "object" ? [infos.get(value)?.id].filter((id) => !!id) : []));
+    const input = Object.fromEntries(Object.entries(decoded).filter(([id]) => configured.has(id)));
+    const sessionContext = { input, sessions: /* @__PURE__ */ new Map(), bookmarks: {}, primaryIds: /* @__PURE__ */ new Set(), allowedIds: configured, operations: /* @__PURE__ */ new Map(), primary: !["GET", "HEAD", "OPTIONS"].includes(request.method.toUpperCase()) || options.ignoreRequestCacheControl !== true && hasCacheBypass(request) || options.freshnessHeader !== void 0 && request.headers.has(options.freshnessHeader), closed: false };
+    return storage.run(sessionContext, async () => {
+      try {
+        const tracked = await trackD1SessionSource(() => handler(request, scoped, context));
+        const response = tracked.value;
+        if (response.status === 101) return response;
+        const headers = new Headers(response.headers);
+        varyD1Bookmarks(headers);
+        const responseBookmarks = responseD1SessionBookmarks(headers, tracked.bookmarks) ?? {};
+        sessionContext.closed = true;
+        const encoded = serializeD1Bookmarks(responseBookmarks);
+        if (encoded && encoded !== "{}") headers.set(D1_BOOKMARK_HEADER, encoded);
+        else headers.delete(D1_BOOKMARK_HEADER);
+        return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+      } finally {
+        sessionContext.closed = true;
+      }
+    });
+  };
+}
+
+export { advanceD1SessionBookmarks, d1SessionBookmarkFloor, d1SessionCacheHooks, d1SessionWarmupRequest, fenceD1Writes, hasCacheBypass, hasFreshnessCookie, hasFreshnessGeneration, prismaD1SessionDatabase, regionalD1MetadataTtl, registerD1SessionAlias, responseD1SessionBookmarks, runD1PrismaScope, runD1SessionOperation, runIsolatedD1Session, runPrimaryD1SessionSource, sessionD1Env, trackD1SessionSource, unwrapD1SessionCacheValue, validFreshnessHeader, varyD1Bookmarks, wrapD1ReadSessionHandler, wrapD1SessionCacheValue };
+//# sourceMappingURL=chunk-WJNCFFF3.js.map
+//# sourceMappingURL=chunk-WJNCFFF3.js.map