@typicalday/firegraph 0.9.0 → 0.11.0

package/dist/chunk-SZ6W4VAS.js

@@ -1,701 +0,0 @@
-import {
-  NODE_RELATION,
-  buildEdgeQueryPlan,
-  computeEdgeDocId,
-  computeNodeDocId
-} from "./chunk-EVUM6ORB.js";
-import {
-  FiregraphError
-} from "./chunk-GLOVWKQH.js";
-
-// src/internal/sqlite-schema.ts
-var FIELD_TO_COLUMN = {
-  aType: "a_type",
-  aUid: "a_uid",
-  axbType: "axb_type",
-  bType: "b_type",
-  bUid: "b_uid",
-  v: "v",
-  createdAt: "created_at",
-  updatedAt: "updated_at"
-};
-function buildSchemaStatements(table) {
-  const t = quoteIdent(table);
-  return [
-    `CREATE TABLE IF NOT EXISTS ${t} (
-      doc_id      TEXT NOT NULL,
-      scope       TEXT NOT NULL DEFAULT '',
-      a_type      TEXT NOT NULL,
-      a_uid       TEXT NOT NULL,
-      axb_type    TEXT NOT NULL,
-      b_type      TEXT NOT NULL,
-      b_uid       TEXT NOT NULL,
-      data        TEXT NOT NULL,
-      v           INTEGER,
-      created_at  INTEGER NOT NULL,
-      updated_at  INTEGER NOT NULL,
-      PRIMARY KEY (scope, doc_id)
-    )`,
-    `CREATE INDEX IF NOT EXISTS ${quoteIdent(`${table}_idx_scope_a_uid`)} ON ${t}(scope, a_uid)`,
-    `CREATE INDEX IF NOT EXISTS ${quoteIdent(`${table}_idx_scope_b_uid`)} ON ${t}(scope, b_uid)`,
-    `CREATE INDEX IF NOT EXISTS ${quoteIdent(`${table}_idx_scope_axb_type_b_uid`)} ON ${t}(scope, axb_type, b_uid)`,
-    `CREATE INDEX IF NOT EXISTS ${quoteIdent(`${table}_idx_scope_a_type`)} ON ${t}(scope, a_type)`,
-    `CREATE INDEX IF NOT EXISTS ${quoteIdent(`${table}_idx_scope_b_type`)} ON ${t}(scope, b_type)`,
-    `CREATE INDEX IF NOT EXISTS ${quoteIdent(`${table}_idx_doc_id`)} ON ${t}(doc_id)`
-  ];
-}
-function quoteIdent(name) {
-  validateTableName(name);
-  return `"${name}"`;
-}
-function validateTableName(name) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
-    throw new Error(`Invalid SQL identifier: ${name}. Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`);
-  }
-}
-
-// src/timestamp.ts
-var GraphTimestampImpl = class _GraphTimestampImpl {
-  constructor(seconds, nanoseconds) {
-    this.seconds = seconds;
-    this.nanoseconds = nanoseconds;
-  }
-  toDate() {
-    return new Date(this.toMillis());
-  }
-  toMillis() {
-    return this.seconds * 1e3 + Math.floor(this.nanoseconds / 1e6);
-  }
-  toJSON() {
-    return { seconds: this.seconds, nanoseconds: this.nanoseconds };
-  }
-  static fromMillis(ms) {
-    const seconds = Math.floor(ms / 1e3);
-    const nanoseconds = (ms - seconds * 1e3) * 1e6;
-    return new _GraphTimestampImpl(seconds, nanoseconds);
-  }
-  static now() {
-    return _GraphTimestampImpl.fromMillis(Date.now());
-  }
-};
-
-// src/internal/sqlite-sql.ts
-function compileFieldRef(field) {
-  const column = FIELD_TO_COLUMN[field];
-  if (column) {
-    return { expr: quoteIdent(column) };
-  }
-  if (field.startsWith("data.")) {
-    const key = field.slice(5);
-    validateJsonPathKey(key);
-    return { expr: 'json_extract("data", ?)', pathParam: `$.${key}` };
-  }
-  if (field === "data") {
-    return { expr: 'json_extract("data", ?)', pathParam: "$" };
-  }
-  throw new FiregraphError(`SQLite backend cannot resolve filter field: ${field}`, "INVALID_QUERY");
-}
-var FIRESTORE_TYPE_NAMES = /* @__PURE__ */ new Set([
-  "Timestamp",
-  "GeoPoint",
-  "VectorValue",
-  "DocumentReference",
-  "FieldValue"
-]);
-function isFirestoreSpecialType(value) {
-  const ctorName = value.constructor?.name;
-  if (ctorName && FIRESTORE_TYPE_NAMES.has(ctorName)) return ctorName;
-  return null;
-}
-function bindValue(value) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    return value;
-  }
-  if (value instanceof Date) return value.getTime();
-  if (typeof value === "object") {
-    const firestoreType = isFirestoreSpecialType(value);
-    if (firestoreType) {
-      throw new FiregraphError(
-        `SQLite backend cannot bind a Firestore ${firestoreType} value \u2014 JSON serialization would silently drop fields and the resulting bind would never match a stored row. Convert to a primitive (e.g. \`ts.toMillis()\` for Timestamp) before filtering or updating.`,
-        "INVALID_QUERY"
-      );
-    }
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
-var JSON_PATH_KEY_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
-function validateJsonPathKey(key) {
-  if (key.length === 0) {
-    throw new FiregraphError(
-      "SQLite backend: empty JSON path component is not allowed",
-      "INVALID_QUERY"
-    );
-  }
-  if (!JSON_PATH_KEY_RE.test(key)) {
-    throw new FiregraphError(
-      `SQLite backend: data field path component "${key}" is not a safe JSON-path identifier. Allowed pattern: /^[A-Za-z_][A-Za-z0-9_-]*$/. Use replaceData (full-data overwrite) for keys with reserved characters (whitespace, dots, brackets, quotes, etc.).`,
-      "INVALID_QUERY"
-    );
-  }
-}
-function compileFilter(filter, params) {
-  const { expr, pathParam } = compileFieldRef(filter.field);
-  if (pathParam !== void 0) params.push(pathParam);
-  switch (filter.op) {
-    case "==":
-      params.push(bindValue(filter.value));
-      return `${expr} = ?`;
-    case "!=":
-      params.push(bindValue(filter.value));
-      return `${expr} != ?`;
-    case "<":
-      params.push(bindValue(filter.value));
-      return `${expr} < ?`;
-    case "<=":
-      params.push(bindValue(filter.value));
-      return `${expr} <= ?`;
-    case ">":
-      params.push(bindValue(filter.value));
-      return `${expr} > ?`;
-    case ">=":
-      params.push(bindValue(filter.value));
-      return `${expr} >= ?`;
-    case "in": {
-      const values = asArray(filter.value, "in");
-      const placeholders = values.map(() => "?").join(", ");
-      for (const v of values) params.push(bindValue(v));
-      return `${expr} IN (${placeholders})`;
-    }
-    case "not-in": {
-      const values = asArray(filter.value, "not-in");
-      const placeholders = values.map(() => "?").join(", ");
-      for (const v of values) params.push(bindValue(v));
-      return `${expr} NOT IN (${placeholders})`;
-    }
-    case "array-contains": {
-      params.push(bindValue(filter.value));
-      return `EXISTS (SELECT 1 FROM json_each(${expr}) WHERE value = ?)`;
-    }
-    case "array-contains-any": {
-      const values = asArray(filter.value, "array-contains-any");
-      const placeholders = values.map(() => "?").join(", ");
-      for (const v of values) params.push(bindValue(v));
-      return `EXISTS (SELECT 1 FROM json_each(${expr}) WHERE value IN (${placeholders}))`;
-    }
-    default:
-      throw new FiregraphError(
-        `SQLite backend does not support filter operator: ${String(filter.op)}`,
-        "INVALID_QUERY"
-      );
-  }
-}
-function asArray(value, op) {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new FiregraphError(`Operator "${op}" requires a non-empty array value`, "INVALID_QUERY");
-  }
-  return value;
-}
-function compileOrderBy(options, params) {
-  if (!options?.orderBy) return "";
-  const { field, direction } = options.orderBy;
-  const { expr, pathParam } = compileFieldRef(field);
-  if (pathParam !== void 0) params.push(pathParam);
-  const dir = direction === "desc" ? "DESC" : "ASC";
-  return ` ORDER BY ${expr} ${dir}`;
-}
-function compileLimit(options, params) {
-  if (options?.limit === void 0) return "";
-  params.push(options.limit);
-  return ` LIMIT ?`;
-}
-function compileSelect(table, scope, filters, options) {
-  const params = [];
-  const conditions = ['"scope" = ?'];
-  params.push(scope);
-  for (const f of filters) {
-    conditions.push(compileFilter(f, params));
-  }
-  let sql = `SELECT * FROM ${quoteIdent(table)} WHERE ${conditions.join(" AND ")}`;
-  const orderClause = compileOrderBy(options, params);
-  sql += orderClause;
-  sql += compileLimit(options, params);
-  return { sql, params };
-}
-function compileSelectGlobal(table, filters, options, scopeNameFilter) {
-  if (filters.length === 0) {
-    throw new FiregraphError(
-      "compileSelectGlobal requires at least one filter \u2014 refusing to issue an unbounded SELECT.",
-      "INVALID_QUERY"
-    );
-  }
-  const params = [];
-  const conditions = [];
-  if (scopeNameFilter) {
-    if (scopeNameFilter.isRoot) {
-      conditions.push(`"scope" = ?`);
-      params.push("");
-    } else {
-      conditions.push(`"scope" LIKE ? ESCAPE '\\'`);
-      params.push(`%/${escapeLike(scopeNameFilter.name)}`);
-    }
-  }
-  for (const f of filters) {
-    conditions.push(compileFilter(f, params));
-  }
-  const sql = `SELECT * FROM ${quoteIdent(table)} WHERE ${conditions.join(" AND ")}` + compileOrderBy(options, params) + compileLimit(options, params);
-  return { sql, params };
-}
-function compileSelectByDocId(table, scope, docId) {
-  return {
-    sql: `SELECT * FROM ${quoteIdent(table)} WHERE "scope" = ? AND "doc_id" = ? LIMIT 1`,
-    params: [scope, docId]
-  };
-}
-function compileSet(table, scope, docId, record, nowMillis) {
-  const sql = `INSERT OR REPLACE INTO ${quoteIdent(table)} (
-    doc_id, scope, a_type, a_uid, axb_type, b_type, b_uid, data, v, created_at, updated_at
-  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-  const params = [
-    docId,
-    scope,
-    record.aType,
-    record.aUid,
-    record.axbType,
-    record.bType,
-    record.bUid,
-    JSON.stringify(record.data ?? {}),
-    record.v ?? null,
-    nowMillis,
-    nowMillis
-  ];
-  return { sql, params };
-}
-function compileUpdate(table, scope, docId, update, nowMillis) {
-  const setClauses = [];
-  const params = [];
-  if (update.replaceData) {
-    setClauses.push(`"data" = ?`);
-    params.push(JSON.stringify(update.replaceData));
-  } else if (update.dataFields && Object.keys(update.dataFields).length > 0) {
-    const entries = Object.entries(update.dataFields);
-    const pathArgs = entries.map(() => `?, ?`).join(", ");
-    setClauses.push(`"data" = json_set(COALESCE("data", '{}'), ${pathArgs})`);
-    for (const [k, v] of entries) {
-      validateJsonPathKey(k);
-      params.push(`$.${k}`);
-      params.push(bindValue(v));
-    }
-  }
-  if (update.v !== void 0) {
-    setClauses.push(`"v" = ?`);
-    params.push(update.v);
-  }
-  setClauses.push(`"updated_at" = ?`);
-  params.push(nowMillis);
-  params.push(scope, docId);
-  return {
-    sql: `UPDATE ${quoteIdent(table)} SET ${setClauses.join(", ")} WHERE "scope" = ? AND "doc_id" = ?`,
-    params
-  };
-}
-function compileDelete(table, scope, docId) {
-  return {
-    sql: `DELETE FROM ${quoteIdent(table)} WHERE "scope" = ? AND "doc_id" = ?`,
-    params: [scope, docId]
-  };
-}
-function compileDeleteScopePrefix(table, scopePrefix) {
-  const escaped = escapeLike(scopePrefix);
-  return {
-    sql: `DELETE FROM ${quoteIdent(table)} WHERE "scope" LIKE ? ESCAPE '\\'`,
-    params: [`${escaped}/%`]
-  };
-}
-function compileCountScopePrefix(table, scopePrefix) {
-  const escaped = escapeLike(scopePrefix);
-  return {
-    sql: `SELECT COUNT(*) AS n FROM ${quoteIdent(table)} WHERE "scope" LIKE ? ESCAPE '\\'`,
-    params: [`${escaped}/%`]
-  };
-}
-function escapeLike(value) {
-  return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-}
-function rowToRecord(row) {
-  const dataString = row.data;
-  const data = dataString ? JSON.parse(dataString) : {};
-  const createdMs = toMillis(row.created_at);
-  const updatedMs = toMillis(row.updated_at);
-  const record = {
-    aType: row.a_type,
-    aUid: row.a_uid,
-    axbType: row.axb_type,
-    bType: row.b_type,
-    bUid: row.b_uid,
-    data,
-    createdAt: GraphTimestampImpl.fromMillis(createdMs),
-    updatedAt: GraphTimestampImpl.fromMillis(updatedMs)
-  };
-  if (row.v !== null && row.v !== void 0) {
-    record.v = Number(row.v);
-  }
-  return record;
-}
-function toMillis(value) {
-  if (typeof value === "number") return value;
-  if (typeof value === "bigint") return Number(value);
-  if (typeof value === "string") return Number(value);
-  return 0;
-}
-
-// src/internal/sqlite-backend.ts
-var DEFAULT_MAX_RETRIES = 3;
-var BASE_RETRY_DELAY_MS = 200;
-var MAX_RETRY_DELAY_MS = 5e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function minDefined(a, b) {
-  if (a === void 0) return b;
-  if (b === void 0) return a;
-  return Math.min(a, b);
-}
-function chunkStatements(statements, maxStatements, maxParams) {
-  const stmtCap = maxStatements && maxStatements > 0 && Number.isFinite(maxStatements) ? Math.floor(maxStatements) : Infinity;
-  const paramCap = maxParams && maxParams > 0 && Number.isFinite(maxParams) ? Math.floor(maxParams) : Infinity;
-  if (stmtCap === Infinity && paramCap === Infinity) {
-    return [statements];
-  }
-  const chunks = [];
-  let current = [];
-  let currentParamCount = 0;
-  for (const stmt of statements) {
-    const stmtParams = stmt.params.length;
-    const wouldExceedStmt = current.length + 1 > stmtCap;
-    const wouldExceedParam = currentParamCount + stmtParams > paramCap;
-    if (current.length > 0 && (wouldExceedStmt || wouldExceedParam)) {
-      chunks.push(current);
-      current = [];
-      currentParamCount = 0;
-    }
-    current.push(stmt);
-    currentParamCount += stmtParams;
-  }
-  if (current.length > 0) chunks.push(current);
-  return chunks;
-}
-var SqliteTransactionBackendImpl = class {
-  constructor(tx, tableName, storageScope) {
-    this.tx = tx;
-    this.tableName = tableName;
-    this.storageScope = storageScope;
-  }
-  async getDoc(docId) {
-    const stmt = compileSelectByDocId(this.tableName, this.storageScope, docId);
-    const rows = await this.tx.all(stmt.sql, stmt.params);
-    return rows.length === 0 ? null : rowToRecord(rows[0]);
-  }
-  async query(filters, options) {
-    const stmt = compileSelect(this.tableName, this.storageScope, filters, options);
-    const rows = await this.tx.all(stmt.sql, stmt.params);
-    return rows.map(rowToRecord);
-  }
-  async setDoc(docId, record) {
-    const stmt = compileSet(this.tableName, this.storageScope, docId, record, Date.now());
-    await this.tx.run(stmt.sql, stmt.params);
-  }
-  async updateDoc(docId, update) {
-    const stmt = compileUpdate(this.tableName, this.storageScope, docId, update, Date.now());
-    const sqlWithReturning = `${stmt.sql} RETURNING "doc_id"`;
-    const rows = await this.tx.all(sqlWithReturning, stmt.params);
-    if (rows.length === 0) {
-      throw new FiregraphError(
-        `updateDoc: no document found for doc_id=${docId} (scope=${this.storageScope})`,
-        "NOT_FOUND"
-      );
-    }
-  }
-  async deleteDoc(docId) {
-    const stmt = compileDelete(this.tableName, this.storageScope, docId);
-    await this.tx.run(stmt.sql, stmt.params);
-  }
-};
-var SqliteBatchBackendImpl = class {
-  constructor(executor, tableName, storageScope) {
-    this.executor = executor;
-    this.tableName = tableName;
-    this.storageScope = storageScope;
-  }
-  statements = [];
-  setDoc(docId, record) {
-    this.statements.push(compileSet(this.tableName, this.storageScope, docId, record, Date.now()));
-  }
-  updateDoc(docId, update) {
-    this.statements.push(
-      compileUpdate(this.tableName, this.storageScope, docId, update, Date.now())
-    );
-  }
-  deleteDoc(docId) {
-    this.statements.push(compileDelete(this.tableName, this.storageScope, docId));
-  }
-  async commit() {
-    if (this.statements.length === 0) return;
-    await this.executor.batch(this.statements);
-    this.statements.length = 0;
-  }
-};
-var SqliteBackendImpl = class _SqliteBackendImpl {
-  constructor(executor, tableName, storageScope, scopePath) {
-    this.executor = executor;
-    this.collectionPath = tableName;
-    this.storageScope = storageScope;
-    this.scopePath = scopePath;
-  }
-  /** Logical table name (returned through `collectionPath` for parity with Firestore). */
-  collectionPath;
-  scopePath;
-  /** Materialized storage scope (interleaved parent UIDs + subgraph names). */
-  storageScope;
-  // --- Reads ---
-  async getDoc(docId) {
-    const stmt = compileSelectByDocId(this.collectionPath, this.storageScope, docId);
-    const rows = await this.executor.all(stmt.sql, stmt.params);
-    return rows.length === 0 ? null : rowToRecord(rows[0]);
-  }
-  async query(filters, options) {
-    const stmt = compileSelect(this.collectionPath, this.storageScope, filters, options);
-    const rows = await this.executor.all(stmt.sql, stmt.params);
-    return rows.map(rowToRecord);
-  }
-  // --- Writes ---
-  async setDoc(docId, record) {
-    const stmt = compileSet(this.collectionPath, this.storageScope, docId, record, Date.now());
-    await this.executor.run(stmt.sql, stmt.params);
-  }
-  async updateDoc(docId, update) {
-    const stmt = compileUpdate(this.collectionPath, this.storageScope, docId, update, Date.now());
-    const sqlWithReturning = `${stmt.sql} RETURNING "doc_id"`;
-    const rows = await this.executor.all(sqlWithReturning, stmt.params);
-    if (rows.length === 0) {
-      throw new FiregraphError(
-        `updateDoc: no document found for doc_id=${docId} (scope=${this.storageScope})`,
-        "NOT_FOUND"
-      );
-    }
-  }
-  async deleteDoc(docId) {
-    const stmt = compileDelete(this.collectionPath, this.storageScope, docId);
-    await this.executor.run(stmt.sql, stmt.params);
-  }
-  // --- Transactions / Batches ---
-  async runTransaction(fn) {
-    if (!this.executor.transaction) {
-      throw new FiregraphError(
-        "Interactive transactions are not supported by this SQLite driver. D1 in particular has no read-then-conditional-write transactions; use a Durable Object SQLite client instead, or rewrite the code path as a batch().",
-        "UNSUPPORTED_OPERATION"
-      );
-    }
-    return this.executor.transaction(async (tx) => {
-      const txBackend = new SqliteTransactionBackendImpl(
-        tx,
-        this.collectionPath,
-        this.storageScope
-      );
-      return fn(txBackend);
-    });
-  }
-  createBatch() {
-    return new SqliteBatchBackendImpl(this.executor, this.collectionPath, this.storageScope);
-  }
-  // --- Subgraphs ---
-  subgraph(parentNodeUid, name) {
-    if (!parentNodeUid || parentNodeUid.includes("/")) {
-      throw new FiregraphError(
-        `Invalid parentNodeUid for subgraph: "${parentNodeUid}". Must be a non-empty string without "/".`,
-        "INVALID_SUBGRAPH"
-      );
-    }
-    if (!name || name.includes("/")) {
-      throw new FiregraphError(
-        `Subgraph name must not contain "/" and must be non-empty: got "${name}". Use chained .subgraph() calls for nested subgraphs.`,
-        "INVALID_SUBGRAPH"
-      );
-    }
-    const newStorageScope = this.storageScope ? `${this.storageScope}/${parentNodeUid}/${name}` : `${parentNodeUid}/${name}`;
-    const newScope = this.scopePath ? `${this.scopePath}/${name}` : name;
-    return new _SqliteBackendImpl(this.executor, this.collectionPath, newStorageScope, newScope);
-  }
-  // --- Cascade & bulk ---
-  async removeNodeCascade(uid, reader, options) {
-    const [outgoingRaw, incomingRaw] = await Promise.all([
-      reader.findEdges({ aUid: uid, allowCollectionScan: true, limit: 0 }),
-      reader.findEdges({ bUid: uid, allowCollectionScan: true, limit: 0 })
-    ]);
-    const seen = /* @__PURE__ */ new Set();
-    const edgeDocIds = [];
-    for (const edge of [...outgoingRaw, ...incomingRaw]) {
-      if (edge.axbType === NODE_RELATION) continue;
-      const docId = computeEdgeDocId(edge.aUid, edge.axbType, edge.bUid);
-      if (!seen.has(docId)) {
-        seen.add(docId);
-        edgeDocIds.push(docId);
-      }
-    }
-    const nodeDocId = computeNodeDocId(uid);
-    const shouldDeleteSubgraphs = options?.deleteSubcollections !== false;
-    let subgraphRowCount = 0;
-    if (shouldDeleteSubgraphs) {
-      const prefix = this.storageScope ? `${this.storageScope}/${uid}` : uid;
-      const countStmt = compileCountScopePrefix(this.collectionPath, prefix);
-      const countRows = await this.executor.all(countStmt.sql, countStmt.params);
-      const first = countRows[0];
-      const n = first?.n;
-      subgraphRowCount = typeof n === "bigint" ? Number(n) : Number(n ?? 0);
-    }
-    const writeStatements = edgeDocIds.map(
-      (id) => compileDelete(this.collectionPath, this.storageScope, id)
-    );
-    writeStatements.push(compileDelete(this.collectionPath, this.storageScope, nodeDocId));
-    if (shouldDeleteSubgraphs) {
-      const prefix = this.storageScope ? `${this.storageScope}/${uid}` : uid;
-      writeStatements.push(compileDeleteScopePrefix(this.collectionPath, prefix));
-    }
-    const {
-      deleted: stmtDeleted,
-      batches,
-      errors
-    } = await this.executeChunkedBatches(writeStatements, options);
-    const allOk = errors.length === 0;
-    const edgesDeleted = allOk ? edgeDocIds.length : 0;
-    const nodeDeleted = allOk;
-    const prefixStatementContribution = shouldDeleteSubgraphs && allOk ? 1 : 0;
-    const deleted = stmtDeleted - prefixStatementContribution + (allOk ? subgraphRowCount : 0);
-    return { deleted, batches, errors, edgesDeleted, nodeDeleted };
-  }
-  async bulkRemoveEdges(params, reader, options) {
-    const effectiveParams = params.limit !== void 0 ? { ...params, allowCollectionScan: params.allowCollectionScan ?? true } : { ...params, limit: 0, allowCollectionScan: params.allowCollectionScan ?? true };
-    const edges = await reader.findEdges(effectiveParams);
-    const docIds = edges.map((e) => computeEdgeDocId(e.aUid, e.axbType, e.bUid));
-    if (docIds.length === 0) {
-      return { deleted: 0, batches: 0, errors: [] };
-    }
-    const statements = docIds.map(
-      (id) => compileDelete(this.collectionPath, this.storageScope, id)
-    );
-    return this.executeChunkedBatches(statements, options);
-  }
-  /**
-   * Submit `statements` to the executor as one or more `batch()` calls,
-   * chunking by `executor.maxBatchSize` (e.g. D1's ~100-statement cap).
-   * Drivers that don't advertise a cap submit everything in one batch,
-   * preserving cross-batch atomicity.
-   *
-   * Each chunk is retried with exponential backoff up to `maxRetries`
-   * (default 3) before being recorded in `errors`. The loop continues past
-   * a permanently failed chunk so the caller still gets partial progress
-   * visibility — to halt on first failure, set `maxRetries: 0` and check
-   * `result.errors.length` after the call.
-   *
-   * Returns `BulkResult`-shaped fields. `deleted` reflects only the
-   * statement count of *successfully committed* batches — a prefix-delete
-   * statement contributes 1 to that total even though it may match many
-   * rows; `removeNodeCascade` patches that up with a pre-counted row total.
-   *
-   * **Atomicity caveat (D1):** when chunking kicks in, atomicity is lost
-   * across chunk boundaries — one chunk may commit while a later one fails.
-   * `removeNodeCascade` is idempotent (deleting the same docs again is a
-   * no-op) so a caller can simply retry on partial failure. `bulkRemoveEdges`
-   * is also idempotent for the same reason. DO SQLite leaves `maxBatchSize`
-   * unset, so everything funnels through one atomic `transactionSync` and
-   * this caveat does not apply.
-   */
-  async executeChunkedBatches(statements, options) {
-    if (statements.length === 0) {
-      return { deleted: 0, batches: 0, errors: [] };
-    }
-    const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
-    const callerBatchSize = options?.batchSize;
-    const stmtCap = minDefined(callerBatchSize, this.executor.maxBatchSize);
-    const chunks = chunkStatements(statements, stmtCap, this.executor.maxBatchParams);
-    const errors = [];
-    let deleted = 0;
-    let batches = 0;
-    const totalBatches = chunks.length;
-    const driverParamCap = this.executor.maxBatchParams;
-    for (let batchIndex = 0; batchIndex < chunks.length; batchIndex++) {
-      const chunk = chunks[batchIndex];
-      const isUnretriableOversize = chunk.length === 1 && driverParamCap !== void 0 && chunk[0].params.length > driverParamCap;
-      let committed = false;
-      let lastError = null;
-      const effectiveRetries = isUnretriableOversize ? 0 : maxRetries;
-      for (let attempt = 0; attempt <= effectiveRetries; attempt++) {
-        try {
-          await this.executor.batch(chunk);
-          committed = true;
-          break;
-        } catch (err) {
-          lastError = err instanceof Error ? err : new Error(String(err));
-          if (attempt < effectiveRetries) {
-            const delay = Math.min(BASE_RETRY_DELAY_MS * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
-            await sleep(delay);
-          }
-        }
-      }
-      if (committed) {
-        deleted += chunk.length;
-        batches += 1;
-      } else if (lastError) {
-        errors.push({
-          batchIndex,
-          error: lastError,
-          operationCount: chunk.length
-        });
-      }
-      if (options?.onProgress) {
-        options.onProgress({
-          completedBatches: batches,
-          totalBatches,
-          deletedSoFar: deleted
-        });
-      }
-    }
-    return { deleted, batches, errors };
-  }
-  // --- Cross-scope (collection group) ---
-  async findEdgesGlobal(params, collectionName) {
-    const plan = buildEdgeQueryPlan(params);
-    if (plan.strategy === "get") {
-      throw new FiregraphError(
-        "findEdgesGlobal() requires a query, not a direct document lookup. Omit one of aUid/axbType/bUid to force a query strategy.",
-        "INVALID_QUERY"
-      );
-    }
-    const name = collectionName ?? this.collectionPath;
-    const scopeNameFilter = {
-      name,
-      isRoot: name === this.collectionPath
-    };
-    const stmt = compileSelectGlobal(
-      this.collectionPath,
-      plan.filters,
-      plan.options,
-      scopeNameFilter
-    );
-    const rows = await this.executor.all(stmt.sql, stmt.params);
-    return rows.map(rowToRecord);
-  }
-};
-function createSqliteBackend(executor, tableName, options = {}) {
-  const storageScope = options.storageScope ?? "";
-  const scopePath = options.scopePath ?? "";
-  return new SqliteBackendImpl(executor, tableName, storageScope, scopePath);
-}
-
-export {
-  buildSchemaStatements,
-  validateTableName,
-  createSqliteBackend
-};
-//# sourceMappingURL=chunk-SZ6W4VAS.js.map