@typicalday/firegraph 0.9.0 → 0.11.0

package/dist/{do-sqlite.cjs → cloudflare/index.cjs}

@@ -154,101 +154,16 @@ var init_serialization = __esm({
   }
 });
 
-// src/do-sqlite.ts
-var do_sqlite_exports = {};
-__export(do_sqlite_exports, {
-  createDOSqliteGraphClient: () => createDOSqliteGraphClient
+// src/cloudflare/index.ts
+var cloudflare_exports = {};
+__export(cloudflare_exports, {
+  DORPCBackend: () => DORPCBackend,
+  FiregraphDO: () => FiregraphDO,
+  buildDOSchemaStatements: () => buildDOSchemaStatements,
+  createDOClient: () => createDOClient,
+  createSiblingClient: () => createSiblingClient
 });
-module.exports = __toCommonJS(do_sqlite_exports);
-
-// src/docid.ts
-var import_node_crypto = require("crypto");
-
-// src/internal/constants.ts
-var NODE_RELATION = "is";
-var DEFAULT_QUERY_LIMIT = 500;
-var BUILTIN_FIELDS = /* @__PURE__ */ new Set([
-  "aType",
-  "aUid",
-  "axbType",
-  "bType",
-  "bUid",
-  "createdAt",
-  "updatedAt"
-]);
-var SHARD_SEPARATOR = ":";
-
-// src/docid.ts
-function computeNodeDocId(uid) {
-  return uid;
-}
-function computeEdgeDocId(aUid, axbType, bUid) {
-  const composite = `${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
-  const hash = (0, import_node_crypto.createHash)("sha256").update(composite).digest("hex");
-  const shard = hash[0];
-  return `${shard}${SHARD_SEPARATOR}${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
-}
-
-// src/batch.ts
-function buildWritableNodeRecord(aType, uid, data) {
-  return { aType, aUid: uid, axbType: NODE_RELATION, bType: aType, bUid: uid, data };
-}
-function buildWritableEdgeRecord(aType, aUid, axbType, bType, bUid, data) {
-  return { aType, aUid, axbType, bType, bUid, data };
-}
-var GraphBatchImpl = class {
-  constructor(backend, registry, scopePath = "") {
-    this.backend = backend;
-    this.registry = registry;
-    this.scopePath = scopePath;
-  }
-  async putNode(aType, uid, data) {
-    if (this.registry) {
-      this.registry.validate(aType, NODE_RELATION, aType, data, this.scopePath);
-    }
-    const docId = computeNodeDocId(uid);
-    const record = buildWritableNodeRecord(aType, uid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record.v = entry.schemaVersion;
-      }
-    }
-    this.backend.setDoc(docId, record);
-  }
-  async putEdge(aType, aUid, axbType, bType, bUid, data) {
-    if (this.registry) {
-      this.registry.validate(aType, axbType, bType, data, this.scopePath);
-    }
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = buildWritableEdgeRecord(aType, aUid, axbType, bType, bUid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, axbType, bType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record.v = entry.schemaVersion;
-      }
-    }
-    this.backend.setDoc(docId, record);
-  }
-  async updateNode(uid, data) {
-    const docId = computeNodeDocId(uid);
-    this.backend.updateDoc(docId, { dataFields: data });
-  }
-  async removeNode(uid) {
-    const docId = computeNodeDocId(uid);
-    this.backend.deleteDoc(docId);
-  }
-  async removeEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    this.backend.deleteDoc(docId);
-  }
-  async commit() {
-    await this.backend.commit();
-  }
-};
-
-// src/dynamic-registry.ts
-var import_node_crypto3 = require("crypto");
+module.exports = __toCommonJS(cloudflare_exports);
 
 // src/errors.ts
 var FiregraphError = class extends Error {
@@ -305,238 +220,963 @@ var MigrationError = class extends FiregraphError {
   }
 };
 
-// src/json-schema.ts
-var import_ajv = __toESM(require("ajv"), 1);
-var import_ajv_formats = __toESM(require("ajv-formats"), 1);
-var ajv = new import_ajv.default({ allErrors: true, strict: false });
-(0, import_ajv_formats.default)(ajv);
-function compileSchema(schema, label) {
-  const validate = ajv.compile(schema);
-  return (data) => {
-    if (!validate(data)) {
-      const errors = validate.errors ?? [];
-      const messages = errors.map((err) => `${err.instancePath || "/"}${err.message ? ": " + err.message : ""}`).join("; ");
-      throw new ValidationError(
-        `Data validation failed${label ? " for " + label : ""}: ${messages}`,
-        errors
-      );
-    }
-  };
-}
+// src/internal/constants.ts
+var NODE_RELATION = "is";
+var DEFAULT_QUERY_LIMIT = 500;
+var BUILTIN_FIELDS = /* @__PURE__ */ new Set([
+  "aType",
+  "aUid",
+  "axbType",
+  "bType",
+  "bUid",
+  "createdAt",
+  "updatedAt"
+]);
+var SHARD_SEPARATOR = ":";
 
-// src/migration.ts
-async function applyMigrationChain(data, currentVersion, targetVersion, migrations) {
-  const sorted = [...migrations].sort((a, b) => a.fromVersion - b.fromVersion);
-  let result = { ...data };
-  let version = currentVersion;
-  for (const step of sorted) {
-    if (step.fromVersion === version) {
-      try {
-        result = await step.up(result);
-      } catch (err) {
-        if (err instanceof MigrationError) throw err;
-        throw new MigrationError(
-          `Migration from v${step.fromVersion} to v${step.toVersion} failed: ${err.message}`
-        );
-      }
-      if (!result || typeof result !== "object") {
-        throw new MigrationError(
-          `Migration from v${step.fromVersion} to v${step.toVersion} returned invalid data (expected object)`
-        );
-      }
-      version = step.toVersion;
-    }
+// src/timestamp.ts
+var GraphTimestampImpl = class _GraphTimestampImpl {
+  constructor(seconds, nanoseconds) {
+    this.seconds = seconds;
+    this.nanoseconds = nanoseconds;
   }
-  if (version !== targetVersion) {
-    throw new MigrationError(
-      `Incomplete migration chain: reached v${version} but target is v${targetVersion}`
+  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/default-indexes.ts
+var DEFAULT_CORE_INDEXES = Object.freeze([
+  { fields: ["aUid"] },
+  { fields: ["bUid"] },
+  { fields: ["aType"] },
+  { fields: ["bType"] },
+  { fields: ["aUid", "axbType"] },
+  { fields: ["axbType", "bUid"] },
+  { fields: ["aType", "axbType"] },
+  { fields: ["axbType", "bType"] }
+]);
+
+// src/internal/sqlite-index-ddl.ts
+var IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var JSON_PATH_KEY_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+function quoteIdent(name) {
+  if (!IDENT_RE.test(name)) {
+    throw new FiregraphError(
+      `Invalid SQL identifier in index DDL: ${name}. Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,
+      "INVALID_INDEX"
     );
   }
-  return result;
+  return `"${name}"`;
 }
-function validateMigrationChain(migrations, label) {
-  if (migrations.length === 0) return;
-  const seen = /* @__PURE__ */ new Set();
-  for (const step of migrations) {
-    if (step.toVersion <= step.fromVersion) {
-      throw new MigrationError(
-        `${label}: migration step has toVersion (${step.toVersion}) <= fromVersion (${step.fromVersion})`
+function fnv1a32(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function normalizeFields(fields) {
+  return fields.map((f) => {
+    if (typeof f === "string") return { path: f, desc: false };
+    if (!f.path || typeof f.path !== "string") {
+      throw new FiregraphError(
+        `IndexSpec field must be a string or { path: string, desc?: boolean }; got ${JSON.stringify(f)}`,
+        "INVALID_INDEX"
       );
     }
-    if (seen.has(step.fromVersion)) {
-      throw new MigrationError(
-        `${label}: duplicate migration step for fromVersion ${step.fromVersion}`
-      );
+    return { path: f.path, desc: !!f.desc };
+  });
+}
+function specFingerprint(spec, leadingColumns) {
+  const normalized = {
+    lead: leadingColumns,
+    fields: normalizeFields(spec.fields),
+    where: spec.where ?? ""
+  };
+  return fnv1a32(JSON.stringify(normalized));
+}
+function compileFieldExpr(path, fieldToColumn) {
+  const col = fieldToColumn[path];
+  if (col) return quoteIdent(col);
+  if (path === "data") {
+    return `json_extract("data", '$')`;
+  }
+  if (path.startsWith("data.")) {
+    const suffix = path.slice(5);
+    const parts = suffix.split(".");
+    for (const part of parts) {
+      if (!JSON_PATH_KEY_RE.test(part)) {
+        throw new FiregraphError(
+          `IndexSpec data path "${path}" has invalid component "${part}". Each component must match /^[A-Za-z_][A-Za-z0-9_-]*$/.`,
+          "INVALID_INDEX"
+        );
+      }
     }
-    seen.add(step.fromVersion);
+    return `json_extract("data", '$.${suffix}')`;
   }
-  const sorted = [...migrations].sort((a, b) => a.fromVersion - b.fromVersion);
-  const targetVersion = Math.max(...migrations.map((m) => m.toVersion));
-  let version = 0;
-  for (const step of sorted) {
-    if (step.fromVersion === version) {
-      version = step.toVersion;
-    } else if (step.fromVersion > version) {
-      throw new MigrationError(
-        `${label}: migration chain has a gap \u2014 no step covers v${version} \u2192 v${step.fromVersion}`
-      );
-    }
+  throw new FiregraphError(
+    `IndexSpec field "${path}" is not a known firegraph field. Use a top-level field (aType, aUid, axbType, bType, bUid, createdAt, updatedAt, v) or a dotted data path like 'data.status'.`,
+    "INVALID_INDEX"
+  );
+}
+function buildIndexDDL(spec, options) {
+  const { table, fieldToColumn, leadingColumns = [] } = options;
+  if (!spec.fields || spec.fields.length === 0) {
+    throw new FiregraphError("IndexSpec.fields must be a non-empty array", "INVALID_INDEX");
   }
-  if (version !== targetVersion) {
-    throw new MigrationError(
-      `${label}: migration chain does not reach v${targetVersion} (stuck at v${version})`
-    );
+  const normalized = normalizeFields(spec.fields);
+  const hash = specFingerprint(spec, leadingColumns);
+  const indexName = `${table}_idx_${hash}`;
+  const cols = [];
+  for (const col of leadingColumns) {
+    cols.push(quoteIdent(col));
   }
-}
-async function migrateRecord(record, registry, globalWriteBack = "off") {
-  const entry = registry.lookup(record.aType, record.axbType, record.bType);
-  if (!entry?.migrations?.length || !entry.schemaVersion) {
-    return { record, migrated: false, writeBack: "off" };
+  for (const f of normalized) {
+    const expr = compileFieldExpr(f.path, fieldToColumn);
+    cols.push(f.desc ? `${expr} DESC` : expr);
   }
-  const currentVersion = record.v ?? 0;
-  if (currentVersion >= entry.schemaVersion) {
-    return { record, migrated: false, writeBack: "off" };
+  let ddl = `CREATE INDEX IF NOT EXISTS ${quoteIdent(indexName)} ON ${quoteIdent(table)}(${cols.join(", ")})`;
+  if (spec.where) {
+    ddl += ` WHERE ${spec.where}`;
   }
-  const migratedData = await applyMigrationChain(
-    record.data,
-    currentVersion,
-    entry.schemaVersion,
-    entry.migrations
-  );
-  const writeBack = entry.migrationWriteBack ?? globalWriteBack ?? "off";
-  return {
-    record: { ...record, data: migratedData, v: entry.schemaVersion },
-    migrated: true,
-    writeBack
-  };
+  return ddl;
 }
-async function migrateRecords(records, registry, globalWriteBack = "off") {
-  return Promise.all(
-    records.map((r) => migrateRecord(r, registry, globalWriteBack))
-  );
+function dedupeIndexSpecs(specs, leadingColumns = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const spec of specs) {
+    const fp = specFingerprint(spec, leadingColumns);
+    if (seen.has(fp)) continue;
+    seen.add(fp);
+    out.push(spec);
+  }
+  return out;
 }
 
-// src/scope.ts
-function matchScope(scopePath, pattern) {
-  if (pattern === "root") return scopePath === "";
-  if (pattern === "**") return true;
-  const pathSegments = scopePath === "" ? [] : scopePath.split("/");
-  const patternSegments = pattern.split("/");
-  return matchSegments(pathSegments, 0, patternSegments, 0);
+// src/cloudflare/schema.ts
+var DO_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"
+};
+var IDENT_RE2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function validateDOTableName(name) {
+  if (!IDENT_RE2.test(name)) {
+    throw new Error(`Invalid SQL identifier: ${name}. Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`);
+  }
 }
-function matchScopeAny(scopePath, patterns) {
-  if (!patterns || patterns.length === 0) return true;
-  return patterns.some((p) => matchScope(scopePath, p));
+function quoteDOIdent(name) {
+  validateDOTableName(name);
+  return `"${name}"`;
 }
-function matchSegments(path, pi, pattern, qi) {
-  if (pi === path.length && qi === pattern.length) return true;
-  if (qi === pattern.length) return false;
-  const seg = pattern[qi];
-  if (seg === "**") {
-    if (qi === pattern.length - 1) return true;
-    for (let skip = 0; skip <= path.length - pi; skip++) {
-      if (matchSegments(path, pi + skip, pattern, qi + 1)) return true;
-    }
-    return false;
-  }
-  if (pi === path.length) return false;
-  if (seg === "*") {
-    return matchSegments(path, pi + 1, pattern, qi + 1);
-  }
-  if (path[pi] === seg) {
-    return matchSegments(path, pi + 1, pattern, qi + 1);
+function buildDOSchemaStatements(table, options = {}) {
+  const t = quoteDOIdent(table);
+  const statements = [
+    `CREATE TABLE IF NOT EXISTS ${t} (
+      doc_id      TEXT NOT NULL PRIMARY KEY,
+      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
+    )`
+  ];
+  const core = options.coreIndexes ?? [...DEFAULT_CORE_INDEXES];
+  const fromRegistry = options.registry?.entries().flatMap((e) => e.indexes ?? []) ?? [];
+  const deduped = dedupeIndexSpecs([...core, ...fromRegistry]);
+  for (const spec of deduped) {
+    statements.push(buildIndexDDL(spec, { table, fieldToColumn: DO_FIELD_TO_COLUMN }));
   }
-  return false;
+  return statements;
 }
 
-// src/registry.ts
-function tripleKey(aType, axbType, bType) {
-  return `${aType}:${axbType}:${bType}`;
+// src/cloudflare/sql.ts
+function compileFieldRef(field) {
+  const column = DO_FIELD_TO_COLUMN[field];
+  if (column) {
+    return { expr: quoteDOIdent(column) };
+  }
+  if (field.startsWith("data.")) {
+    const suffix = field.slice(5);
+    for (const part of suffix.split(".")) {
+      validateJsonPathKey(part);
+    }
+    return { expr: `json_extract("data", '$.${suffix}')` };
+  }
+  if (field === "data") {
+    return { expr: `json_extract("data", '$')` };
+  }
+  throw new FiregraphError(
+    `DO SQLite backend cannot resolve filter field: ${field}`,
+    "INVALID_QUERY"
+  );
 }
-function tripleKeyFor(e) {
-  return tripleKey(e.aType, e.axbType, e.bType);
+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 createRegistry(input) {
-  const map = /* @__PURE__ */ new Map();
-  let entries;
-  if (Array.isArray(input)) {
-    entries = input;
-  } else {
-    entries = discoveryToEntries(input);
+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;
   }
-  const entryList = Object.freeze([...entries]);
-  for (const entry of entries) {
-    if (entry.targetGraph && entry.targetGraph.includes("/")) {
-      throw new ValidationError(
-        `Entry (${entry.aType}) -[${entry.axbType}]-> (${entry.bType}) has invalid targetGraph "${entry.targetGraph}" \u2014 must be a single segment (no "/")`
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "object") {
+    const firestoreType = isFirestoreSpecialType(value);
+    if (firestoreType) {
+      throw new FiregraphError(
+        `DO 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"
       );
     }
-    if (entry.migrations?.length) {
-      const label = `Entry (${entry.aType}) -[${entry.axbType}]-> (${entry.bType})`;
-      validateMigrationChain(entry.migrations, label);
-      entry.schemaVersion = Math.max(...entry.migrations.map((m) => m.toVersion));
-    } else {
-      entry.schemaVersion = void 0;
-    }
-    const key = tripleKey(entry.aType, entry.axbType, entry.bType);
-    const validator = entry.jsonSchema ? compileSchema(entry.jsonSchema, `(${entry.aType}) -[${entry.axbType}]-> (${entry.bType})`) : void 0;
-    map.set(key, { entry, validate: validator });
+    return JSON.stringify(value);
   }
-  const axbIndex = /* @__PURE__ */ new Map();
-  const axbBuild = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const existing = axbBuild.get(entry.axbType);
-    if (existing) {
-      existing.push(entry);
-    } else {
-      axbBuild.set(entry.axbType, [entry]);
+  return String(value);
+}
+var JSON_PATH_KEY_RE2 = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+function validateJsonPathKey(key) {
+  if (key.length === 0) {
+    throw new FiregraphError(
+      "DO SQLite backend: empty JSON path component is not allowed",
+      "INVALID_QUERY"
+    );
+  }
+  if (!JSON_PATH_KEY_RE2.test(key)) {
+    throw new FiregraphError(
+      `DO 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 } = compileFieldRef(filter.field);
+  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(
+        `DO SQLite backend does not support filter operator: ${String(filter.op)}`,
+        "INVALID_QUERY"
+      );
   }
-  for (const [key, arr] of axbBuild) {
-    axbIndex.set(key, Object.freeze(arr));
+}
+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 } = compileFieldRef(field);
+  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 compileDOSelect(table, filters, options) {
+  const params = [];
+  const conditions = [];
+  for (const f of filters) {
+    conditions.push(compileFilter(f, params));
   }
+  const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+  let sql = `SELECT * FROM ${quoteDOIdent(table)}${where}`;
+  sql += compileOrderBy(options, params);
+  sql += compileLimit(options, params);
+  return { sql, params };
+}
+function compileDOSelectByDocId(table, docId) {
   return {
-    lookup(aType, axbType, bType) {
-      return map.get(tripleKey(aType, axbType, bType))?.entry;
-    },
-    lookupByAxbType(axbType) {
-      return axbIndex.get(axbType) ?? [];
-    },
-    validate(aType, axbType, bType, data, scopePath) {
-      const rec = map.get(tripleKey(aType, axbType, bType));
-      if (!rec) {
-        throw new RegistryViolationError(aType, axbType, bType);
-      }
-      if (scopePath !== void 0 && rec.entry.allowedIn && rec.entry.allowedIn.length > 0) {
-        if (!matchScopeAny(scopePath, rec.entry.allowedIn)) {
-          throw new RegistryScopeError(aType, axbType, bType, scopePath, rec.entry.allowedIn);
-        }
-      }
-      if (rec.validate) {
-        try {
-          rec.validate(data);
-        } catch (err) {
-          if (err instanceof ValidationError) throw err;
-          throw new ValidationError(
-            `Data validation failed for (${aType}) -[${axbType}]-> (${bType})`,
-            err
-          );
-        }
-      }
-    },
-    entries() {
-      return entryList;
+    sql: `SELECT * FROM ${quoteDOIdent(table)} WHERE "doc_id" = ? LIMIT 1`,
+    params: [docId]
+  };
+}
+function compileDOSet(table, docId, record, nowMillis) {
+  const sql = `INSERT OR REPLACE INTO ${quoteDOIdent(table)} (
+    doc_id, a_type, a_uid, axb_type, b_type, b_uid, data, v, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+  const params = [
+    docId,
+    record.aType,
+    record.aUid,
+    record.axbType,
+    record.bType,
+    record.bUid,
+    JSON.stringify(record.data ?? {}),
+    record.v ?? null,
+    nowMillis,
+    nowMillis
+  ];
+  return { sql, params };
+}
+function compileDOUpdate(table, 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(docId);
+  return {
+    sql: `UPDATE ${quoteDOIdent(table)} SET ${setClauses.join(", ")} WHERE "doc_id" = ?`,
+    params
   };
 }
-function createMergedRegistry(base, extension) {
-  const baseKeys = new Set(base.entries().map(tripleKeyFor));
+function compileDODelete(table, docId) {
   return {
-    lookup(aType, axbType, bType) {
-      return base.lookup(aType, axbType, bType) ?? extension.lookup(aType, axbType, bType);
-    },
-    lookupByAxbType(axbType) {
-      const baseResults = base.lookupByAxbType(axbType);
+    sql: `DELETE FROM ${quoteDOIdent(table)} WHERE "doc_id" = ?`,
+    params: [docId]
+  };
+}
+function compileDODeleteAll(table) {
+  return {
+    sql: `DELETE FROM ${quoteDOIdent(table)}`,
+    params: []
+  };
+}
+function rowToDORecord(row) {
+  const dataString = row.data;
+  const data = dataString ? JSON.parse(dataString) : {};
+  const createdAtMs = toMillis(row.created_at);
+  const updatedAtMs = 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,
+    createdAtMs,
+    updatedAtMs
+  };
+  if (row.v !== null && row.v !== void 0) {
+    record.v = Number(row.v);
+  }
+  return record;
+}
+function hydrateDORecord(wire) {
+  const record = {
+    aType: wire.aType,
+    aUid: wire.aUid,
+    axbType: wire.axbType,
+    bType: wire.bType,
+    bUid: wire.bUid,
+    data: wire.data,
+    createdAt: GraphTimestampImpl.fromMillis(wire.createdAtMs),
+    updatedAt: GraphTimestampImpl.fromMillis(wire.updatedAtMs)
+  };
+  if (wire.v !== void 0) {
+    record.v = wire.v;
+  }
+  return record;
+}
+function toMillis(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  throw new FiregraphError(
+    `DO SQLite row has non-numeric timestamp column: ${typeof value} (${String(value)})`,
+    "INVALID_QUERY"
+  );
+}
+
+// src/cloudflare/backend.ts
+function validateSegment(value, label) {
+  if (!value || value.includes("/")) {
+    throw new FiregraphError(
+      `Invalid ${label} for subgraph: "${value}". Must be non-empty and not contain "/".`,
+      "INVALID_SUBGRAPH"
+    );
+  }
+}
+function transactionsUnsupported() {
+  return new FiregraphError(
+    "Interactive transactions are not supported by the Cloudflare DO backend. Use `batch()` for atomic multi-write commits, or restructure the read-then-conditional-write as an explicit read \u2192 decide \u2192 batch sequence.",
+    "UNSUPPORTED_OPERATION"
+  );
+}
+var DORPCBatchBackend = class {
+  constructor(getStub) {
+    this.getStub = getStub;
+  }
+  ops = [];
+  setDoc(docId, record) {
+    this.ops.push({ kind: "set", docId, record });
+  }
+  updateDoc(docId, update) {
+    this.ops.push({ kind: "update", docId, update });
+  }
+  deleteDoc(docId) {
+    this.ops.push({ kind: "delete", docId });
+  }
+  async commit() {
+    if (this.ops.length === 0) return;
+    const ops = this.ops.slice();
+    this.ops.length = 0;
+    await this.getStub()._fgBatch(ops);
+  }
+};
+var DORPCBackend = class _DORPCBackend {
+  collectionPath = "firegraph";
+  scopePath;
+  /** @internal */
+  storageKey;
+  /** @internal */
+  namespace;
+  registryAccessor;
+  /** @internal — see `DORPCBackendOptions.makeSiblingClient` for the union-type rationale. */
+  makeSiblingClient;
+  cachedStub = null;
+  constructor(namespace, options) {
+    this.namespace = namespace;
+    this.scopePath = options.scopePath ?? "";
+    this.storageKey = options.storageKey;
+    this.registryAccessor = options.registryAccessor;
+    this.makeSiblingClient = options.makeSiblingClient;
+  }
+  get stub() {
+    if (!this.cachedStub) {
+      const id = this.namespace.idFromName(this.storageKey);
+      this.cachedStub = this.namespace.get(id);
+    }
+    return this.cachedStub;
+  }
+  // --- Reads ---
+  async getDoc(docId) {
+    const wire = await this.stub._fgGetDoc(docId);
+    return wire ? hydrateDORecord(wire) : null;
+  }
+  async query(filters, options) {
+    const wires = await this.stub._fgQuery(filters, options);
+    return wires.map(hydrateDORecord);
+  }
+  // --- Writes ---
+  async setDoc(docId, record) {
+    return this.stub._fgSetDoc(docId, record);
+  }
+  async updateDoc(docId, update) {
+    return this.stub._fgUpdateDoc(docId, update);
+  }
+  async deleteDoc(docId) {
+    return this.stub._fgDeleteDoc(docId);
+  }
+  // --- Transactions / batches ---
+  async runTransaction(_fn) {
+    void _fn;
+    throw transactionsUnsupported();
+  }
+  createBatch() {
+    return new DORPCBatchBackend(() => this.stub);
+  }
+  // --- Subgraphs ---
+  subgraph(parentNodeUid, name) {
+    validateSegment(parentNodeUid, "parentNodeUid");
+    validateSegment(name, "subgraph name");
+    const newStorageKey = `${this.storageKey}/${parentNodeUid}/${name}`;
+    const newScopePath = this.scopePath ? `${this.scopePath}/${name}` : name;
+    return new _DORPCBackend(this.namespace, {
+      scopePath: newScopePath,
+      storageKey: newStorageKey,
+      // Subgraph backends share the same live registry accessor so a cascade
+      // invoked on a subgraph client still fans out correctly. The sibling
+      // factory is also carried forward so `createSiblingClient` works from
+      // any subgraph client in the chain.
+      registryAccessor: this.registryAccessor,
+      makeSiblingClient: this.makeSiblingClient
+    });
+  }
+  // --- Cascade & bulk ---
+  async removeNodeCascade(uid, reader, options) {
+    const shouldDeleteSubgraphs = options?.deleteSubcollections !== false;
+    const registry = this.registryAccessor?.();
+    if (shouldDeleteSubgraphs && registry) {
+      const node = await reader.getNode(uid);
+      if (node) {
+        const topology = registry.getSubgraphTopology(node.aType);
+        for (const entry of topology) {
+          const target = entry.targetGraph;
+          const childBackend = this.subgraph(uid, target);
+          await childBackend.destroyRecursively(registry);
+        }
+      }
+    }
+    return this.stub._fgRemoveNodeCascade(uid);
+  }
+  async bulkRemoveEdges(params, _reader, options) {
+    void _reader;
+    return this.stub._fgBulkRemoveEdges(params, options);
+  }
+  // --- Cross-scope queries ---
+  //
+  // `findEdgesGlobal` is deliberately NOT defined on this class. The
+  // GraphClient checks for its presence before running query planning and
+  // throws `UNSUPPORTED_OPERATION` when absent, giving the caller an
+  // immediate, accurate error. Defining the method with a throwing body
+  // would only surface the same error AFTER `checkQuerySafety` had already
+  // fired — and for scan-unsafe calls that results in a misleading
+  // `QuerySafetyError` ("add filters like aUid+axbType") when no filter
+  // combination would actually make the call work on this backend. See the
+  // "What's not supported" section in `createDOClient` for the design
+  // rationale (no collection-group index across DOs).
+  // --- Destroy helpers ---
+  /**
+   * Wipe this DO's storage. The DO itself can't be deleted — its ID
+   * persists forever — but its rows can be emptied, which is what the
+   * cascade walk does on every descendant subgraph DO.
+   *
+   * Exposed on the concrete class (not `StorageBackend`) so generic
+   * backend code doesn't reach for it.
+   */
+  async destroy() {
+    await this.stub._fgDestroy();
+  }
+  /**
+   * Tear down every descendant subgraph DO, then wipe this DO's own rows.
+   *
+   * Invoked by cross-DO cascade: for each node in this DO we enumerate the
+   * subgraph topology and recurse into child DOs depth-first before
+   * wiping the current DO. The current DO's own rows are destroyed last so
+   * that a partial failure mid-recursion leaves the caller's reader able
+   * to discover what's still present.
+   *
+   * @internal
+   */
+  async destroyRecursively(registry) {
+    const nodes = await this.query([{ field: "axbType", op: "==", value: NODE_RELATION }]);
+    for (const node of nodes) {
+      const topology = registry.getSubgraphTopology(node.aType);
+      for (const entry of topology) {
+        const target = entry.targetGraph;
+        const childBackend = this.subgraph(node.aUid, target);
+        await childBackend.destroyRecursively(registry);
+      }
+    }
+    await this.destroy();
+  }
+};
+
+// src/docid.ts
+var import_node_crypto = require("crypto");
+function computeNodeDocId(uid) {
+  return uid;
+}
+function computeEdgeDocId(aUid, axbType, bUid) {
+  const composite = `${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
+  const hash = (0, import_node_crypto.createHash)("sha256").update(composite).digest("hex");
+  const shard = hash[0];
+  return `${shard}${SHARD_SEPARATOR}${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
+}
+
+// src/batch.ts
+function buildWritableNodeRecord(aType, uid, data) {
+  return { aType, aUid: uid, axbType: NODE_RELATION, bType: aType, bUid: uid, data };
+}
+function buildWritableEdgeRecord(aType, aUid, axbType, bType, bUid, data) {
+  return { aType, aUid, axbType, bType, bUid, data };
+}
+var GraphBatchImpl = class {
+  constructor(backend, registry, scopePath = "") {
+    this.backend = backend;
+    this.registry = registry;
+    this.scopePath = scopePath;
+  }
+  async putNode(aType, uid, data) {
+    if (this.registry) {
+      this.registry.validate(aType, NODE_RELATION, aType, data, this.scopePath);
+    }
+    const docId = computeNodeDocId(uid);
+    const record = buildWritableNodeRecord(aType, uid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record.v = entry.schemaVersion;
+      }
+    }
+    this.backend.setDoc(docId, record);
+  }
+  async putEdge(aType, aUid, axbType, bType, bUid, data) {
+    if (this.registry) {
+      this.registry.validate(aType, axbType, bType, data, this.scopePath);
+    }
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record = buildWritableEdgeRecord(aType, aUid, axbType, bType, bUid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, axbType, bType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record.v = entry.schemaVersion;
+      }
+    }
+    this.backend.setDoc(docId, record);
+  }
+  async updateNode(uid, data) {
+    const docId = computeNodeDocId(uid);
+    this.backend.updateDoc(docId, { dataFields: data });
+  }
+  async removeNode(uid) {
+    const docId = computeNodeDocId(uid);
+    this.backend.deleteDoc(docId);
+  }
+  async removeEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    this.backend.deleteDoc(docId);
+  }
+  async commit() {
+    await this.backend.commit();
+  }
+};
+
+// src/dynamic-registry.ts
+var import_node_crypto3 = require("crypto");
+
+// src/json-schema.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var ajv = new import_ajv.default({ allErrors: true, strict: false });
+(0, import_ajv_formats.default)(ajv);
+function compileSchema(schema, label) {
+  const validate = ajv.compile(schema);
+  return (data) => {
+    if (!validate(data)) {
+      const errors = validate.errors ?? [];
+      const messages = errors.map((err) => `${err.instancePath || "/"}${err.message ? ": " + err.message : ""}`).join("; ");
+      throw new ValidationError(
+        `Data validation failed${label ? " for " + label : ""}: ${messages}`,
+        errors
+      );
+    }
+  };
+}
+
+// src/migration.ts
+async function applyMigrationChain(data, currentVersion, targetVersion, migrations) {
+  const sorted = [...migrations].sort((a, b) => a.fromVersion - b.fromVersion);
+  let result = { ...data };
+  let version = currentVersion;
+  for (const step of sorted) {
+    if (step.fromVersion === version) {
+      try {
+        result = await step.up(result);
+      } catch (err) {
+        if (err instanceof MigrationError) throw err;
+        throw new MigrationError(
+          `Migration from v${step.fromVersion} to v${step.toVersion} failed: ${err.message}`
+        );
+      }
+      if (!result || typeof result !== "object") {
+        throw new MigrationError(
+          `Migration from v${step.fromVersion} to v${step.toVersion} returned invalid data (expected object)`
+        );
+      }
+      version = step.toVersion;
+    }
+  }
+  if (version !== targetVersion) {
+    throw new MigrationError(
+      `Incomplete migration chain: reached v${version} but target is v${targetVersion}`
+    );
+  }
+  return result;
+}
+function validateMigrationChain(migrations, label) {
+  if (migrations.length === 0) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const step of migrations) {
+    if (step.toVersion <= step.fromVersion) {
+      throw new MigrationError(
+        `${label}: migration step has toVersion (${step.toVersion}) <= fromVersion (${step.fromVersion})`
+      );
+    }
+    if (seen.has(step.fromVersion)) {
+      throw new MigrationError(
+        `${label}: duplicate migration step for fromVersion ${step.fromVersion}`
+      );
+    }
+    seen.add(step.fromVersion);
+  }
+  const sorted = [...migrations].sort((a, b) => a.fromVersion - b.fromVersion);
+  const targetVersion = Math.max(...migrations.map((m) => m.toVersion));
+  let version = 0;
+  for (const step of sorted) {
+    if (step.fromVersion === version) {
+      version = step.toVersion;
+    } else if (step.fromVersion > version) {
+      throw new MigrationError(
+        `${label}: migration chain has a gap \u2014 no step covers v${version} \u2192 v${step.fromVersion}`
+      );
+    }
+  }
+  if (version !== targetVersion) {
+    throw new MigrationError(
+      `${label}: migration chain does not reach v${targetVersion} (stuck at v${version})`
+    );
+  }
+}
+async function migrateRecord(record, registry, globalWriteBack = "off") {
+  const entry = registry.lookup(record.aType, record.axbType, record.bType);
+  if (!entry?.migrations?.length || !entry.schemaVersion) {
+    return { record, migrated: false, writeBack: "off" };
+  }
+  const currentVersion = record.v ?? 0;
+  if (currentVersion >= entry.schemaVersion) {
+    return { record, migrated: false, writeBack: "off" };
+  }
+  const migratedData = await applyMigrationChain(
+    record.data,
+    currentVersion,
+    entry.schemaVersion,
+    entry.migrations
+  );
+  const writeBack = entry.migrationWriteBack ?? globalWriteBack ?? "off";
+  return {
+    record: { ...record, data: migratedData, v: entry.schemaVersion },
+    migrated: true,
+    writeBack
+  };
+}
+async function migrateRecords(records, registry, globalWriteBack = "off") {
+  return Promise.all(records.map((r) => migrateRecord(r, registry, globalWriteBack)));
+}
+
+// src/scope.ts
+function matchScope(scopePath, pattern) {
+  if (pattern === "root") return scopePath === "";
+  if (pattern === "**") return true;
+  const pathSegments = scopePath === "" ? [] : scopePath.split("/");
+  const patternSegments = pattern.split("/");
+  return matchSegments(pathSegments, 0, patternSegments, 0);
+}
+function matchScopeAny(scopePath, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  return patterns.some((p) => matchScope(scopePath, p));
+}
+function matchSegments(path, pi, pattern, qi) {
+  if (pi === path.length && qi === pattern.length) return true;
+  if (qi === pattern.length) return false;
+  const seg = pattern[qi];
+  if (seg === "**") {
+    if (qi === pattern.length - 1) return true;
+    for (let skip = 0; skip <= path.length - pi; skip++) {
+      if (matchSegments(path, pi + skip, pattern, qi + 1)) return true;
+    }
+    return false;
+  }
+  if (pi === path.length) return false;
+  if (seg === "*") {
+    return matchSegments(path, pi + 1, pattern, qi + 1);
+  }
+  if (path[pi] === seg) {
+    return matchSegments(path, pi + 1, pattern, qi + 1);
+  }
+  return false;
+}
+
+// src/registry.ts
+function tripleKey(aType, axbType, bType) {
+  return `${aType}:${axbType}:${bType}`;
+}
+function tripleKeyFor(e) {
+  return tripleKey(e.aType, e.axbType, e.bType);
+}
+function createRegistry(input) {
+  const map = /* @__PURE__ */ new Map();
+  let entries;
+  if (Array.isArray(input)) {
+    entries = input;
+  } else {
+    entries = discoveryToEntries(input);
+  }
+  const entryList = Object.freeze([...entries]);
+  for (const entry of entries) {
+    if (entry.targetGraph && entry.targetGraph.includes("/")) {
+      throw new ValidationError(
+        `Entry (${entry.aType}) -[${entry.axbType}]-> (${entry.bType}) has invalid targetGraph "${entry.targetGraph}" \u2014 must be a single segment (no "/")`
+      );
+    }
+    if (entry.migrations?.length) {
+      const label = `Entry (${entry.aType}) -[${entry.axbType}]-> (${entry.bType})`;
+      validateMigrationChain(entry.migrations, label);
+      entry.schemaVersion = Math.max(...entry.migrations.map((m) => m.toVersion));
+    } else {
+      entry.schemaVersion = void 0;
+    }
+    const key = tripleKey(entry.aType, entry.axbType, entry.bType);
+    const validator = entry.jsonSchema ? compileSchema(entry.jsonSchema, `(${entry.aType}) -[${entry.axbType}]-> (${entry.bType})`) : void 0;
+    map.set(key, { entry, validate: validator });
+  }
+  const axbIndex = /* @__PURE__ */ new Map();
+  const axbBuild = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = axbBuild.get(entry.axbType);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      axbBuild.set(entry.axbType, [entry]);
+    }
+  }
+  for (const [key, arr] of axbBuild) {
+    axbIndex.set(key, Object.freeze(arr));
+  }
+  const topologyIndex = /* @__PURE__ */ new Map();
+  const topologyBuild = /* @__PURE__ */ new Map();
+  const topologySeen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.targetGraph) continue;
+    let seen = topologySeen.get(entry.aType);
+    if (!seen) {
+      seen = /* @__PURE__ */ new Set();
+      topologySeen.set(entry.aType, seen);
+    }
+    if (seen.has(entry.targetGraph)) continue;
+    seen.add(entry.targetGraph);
+    const existing = topologyBuild.get(entry.aType);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      topologyBuild.set(entry.aType, [entry]);
+    }
+  }
+  for (const [key, arr] of topologyBuild) {
+    topologyIndex.set(key, Object.freeze(arr));
+  }
+  return {
+    lookup(aType, axbType, bType) {
+      return map.get(tripleKey(aType, axbType, bType))?.entry;
+    },
+    lookupByAxbType(axbType) {
+      return axbIndex.get(axbType) ?? [];
+    },
+    getSubgraphTopology(aType) {
+      return topologyIndex.get(aType) ?? [];
+    },
+    validate(aType, axbType, bType, data, scopePath) {
+      const rec = map.get(tripleKey(aType, axbType, bType));
+      if (!rec) {
+        throw new RegistryViolationError(aType, axbType, bType);
+      }
+      if (scopePath !== void 0 && rec.entry.allowedIn && rec.entry.allowedIn.length > 0) {
+        if (!matchScopeAny(scopePath, rec.entry.allowedIn)) {
+          throw new RegistryScopeError(aType, axbType, bType, scopePath, rec.entry.allowedIn);
+        }
+      }
+      if (rec.validate) {
+        try {
+          rec.validate(data);
+        } catch (err) {
+          if (err instanceof ValidationError) throw err;
+          throw new ValidationError(
+            `Data validation failed for (${aType}) -[${axbType}]-> (${bType})`,
+            err
+          );
+        }
+      }
+    },
+    entries() {
+      return entryList;
+    }
+  };
+}
+function createMergedRegistry(base, extension) {
+  const baseKeys = new Set(base.entries().map(tripleKeyFor));
+  return {
+    lookup(aType, axbType, bType) {
+      return base.lookup(aType, axbType, bType) ?? extension.lookup(aType, axbType, bType);
+    },
+    lookupByAxbType(axbType) {
+      const baseResults = base.lookupByAxbType(axbType);
       const extResults = extension.lookupByAxbType(axbType);
       if (extResults.length === 0) return baseResults;
       if (baseResults.length === 0) return extResults;
@@ -549,6 +1189,21 @@ function createMergedRegistry(base, extension) {
       }
       return Object.freeze(merged);
     },
+    getSubgraphTopology(aType) {
+      const baseResults = base.getSubgraphTopology(aType);
+      const extResults = extension.getSubgraphTopology(aType);
+      if (extResults.length === 0) return baseResults;
+      if (baseResults.length === 0) return extResults;
+      const seen = new Set(baseResults.map((e) => e.targetGraph));
+      const merged = [...baseResults];
+      for (const entry of extResults) {
+        if (!seen.has(entry.targetGraph)) {
+          seen.add(entry.targetGraph);
+          merged.push(entry);
+        }
+      }
+      return Object.freeze(merged);
+    },
     validate(aType, axbType, bType, data, scopePath) {
       if (baseKeys.has(tripleKey(aType, axbType, bType))) {
         return base.validate(aType, axbType, bType, data, scopePath);
@@ -581,7 +1236,8 @@ function discoveryToEntries(discovery) {
       subtitleField: entity.subtitleField,
       allowedIn: entity.allowedIn,
       migrations: entity.migrations,
-      migrationWriteBack: entity.migrationWriteBack
+      migrationWriteBack: entity.migrationWriteBack,
+      indexes: entity.indexes
     });
   }
   for (const [axbType, entity] of discovery.edges) {
@@ -609,7 +1265,8 @@ function discoveryToEntries(discovery) {
           allowedIn: entity.allowedIn,
           targetGraph: resolvedTargetGraph,
           migrations: entity.migrations,
-          migrationWriteBack: entity.migrationWriteBack
+          migrationWriteBack: entity.migrationWriteBack,
+          indexes: entity.indexes
         });
       }
     }
@@ -1132,246 +1789,22 @@ var GraphTransactionImpl = class {
         v: result.record.v
       });
     }
-    return result.record;
-  }
-  async edgeExists(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = await this.backend.getDoc(docId);
-    return record !== null;
-  }
-  checkQuerySafety(filters, allowCollectionScan) {
-    if (allowCollectionScan || this.scanProtection === "off") return;
-    const result = analyzeQuerySafety(filters);
-    if (result.safe) return;
-    if (this.scanProtection === "error") {
-      throw new QuerySafetyError(result.reason);
-    }
-    console.warn(`[firegraph] Query safety warning: ${result.reason}`);
-  }
-  async findEdges(params) {
-    const plan = buildEdgeQueryPlan(params);
-    let records;
-    if (plan.strategy === "get") {
-      const record = await this.backend.getDoc(plan.docId);
-      records = record ? [record] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.backend.query(plan.filters, plan.options);
-    }
-    return this.applyMigrations(records);
-  }
-  async findNodes(params) {
-    const plan = buildNodeQueryPlan(params);
-    let records;
-    if (plan.strategy === "get") {
-      const record = await this.backend.getDoc(plan.docId);
-      records = record ? [record] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.backend.query(plan.filters, plan.options);
-    }
-    return this.applyMigrations(records);
-  }
-  async applyMigrations(records) {
-    if (!this.registry || records.length === 0) return records;
-    const results = await migrateRecords(records, this.registry, this.globalWriteBack);
-    for (const result of results) {
-      if (result.migrated && result.writeBack !== "off") {
-        const docId = result.record.axbType === NODE_RELATION ? computeNodeDocId(result.record.aUid) : computeEdgeDocId(result.record.aUid, result.record.axbType, result.record.bUid);
-        await this.backend.updateDoc(docId, {
-          replaceData: result.record.data,
-          v: result.record.v
-        });
-      }
-    }
-    return results.map((r) => r.record);
-  }
-  async putNode(aType, uid, data) {
-    if (this.registry) {
-      this.registry.validate(aType, NODE_RELATION, aType, data, this.scopePath);
-    }
-    const docId = computeNodeDocId(uid);
-    const record = buildWritableNodeRecord2(aType, uid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record.v = entry.schemaVersion;
-      }
-    }
-    await this.backend.setDoc(docId, record);
-  }
-  async putEdge(aType, aUid, axbType, bType, bUid, data) {
-    if (this.registry) {
-      this.registry.validate(aType, axbType, bType, data, this.scopePath);
-    }
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = buildWritableEdgeRecord2(aType, aUid, axbType, bType, bUid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, axbType, bType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record.v = entry.schemaVersion;
-      }
-    }
-    await this.backend.setDoc(docId, record);
-  }
-  async updateNode(uid, data) {
-    const docId = computeNodeDocId(uid);
-    await this.backend.updateDoc(docId, { dataFields: data });
-  }
-  async removeNode(uid) {
-    const docId = computeNodeDocId(uid);
-    await this.backend.deleteDoc(docId);
-  }
-  async removeEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    await this.backend.deleteDoc(docId);
-  }
-};
-
-// src/client.ts
-var RESERVED_TYPE_NAMES = /* @__PURE__ */ new Set([META_NODE_TYPE, META_EDGE_TYPE]);
-function buildWritableNodeRecord3(aType, uid, data) {
-  return { aType, aUid: uid, axbType: NODE_RELATION, bType: aType, bUid: uid, data };
-}
-function buildWritableEdgeRecord3(aType, aUid, axbType, bType, bUid, data) {
-  return { aType, aUid, axbType, bType, bUid, data };
-}
-var GraphClientImpl = class _GraphClientImpl {
-  constructor(backend, options, metaBackend) {
-    this.backend = backend;
-    this.globalWriteBack = options?.migrationWriteBack ?? "off";
-    this.migrationSandbox = options?.migrationSandbox;
-    if (options?.registryMode) {
-      this.dynamicConfig = options.registryMode;
-      this.bootstrapRegistry = createBootstrapRegistry();
-      if (options.registry) {
-        this.staticRegistry = options.registry;
-      }
-      this.metaBackend = metaBackend;
-    } else {
-      this.staticRegistry = options?.registry;
-    }
-    this.scanProtection = options?.scanProtection ?? "error";
-  }
-  scanProtection;
-  // Static mode
-  staticRegistry;
-  // Dynamic mode
-  dynamicConfig;
-  bootstrapRegistry;
-  dynamicRegistry;
-  metaBackend;
-  // Migration settings
-  globalWriteBack;
-  migrationSandbox;
-  // ---------------------------------------------------------------------------
-  // Backend access (exposed for traversal helpers and subgraph cloning)
-  // ---------------------------------------------------------------------------
-  /** @internal */
-  getBackend() {
-    return this.backend;
-  }
-  // ---------------------------------------------------------------------------
-  // Registry routing
-  // ---------------------------------------------------------------------------
-  getRegistryForType(aType) {
-    if (!this.dynamicConfig) return this.staticRegistry;
-    if (aType === META_NODE_TYPE || aType === META_EDGE_TYPE) {
-      return this.bootstrapRegistry;
-    }
-    return this.dynamicRegistry ?? this.staticRegistry ?? this.bootstrapRegistry;
-  }
-  getBackendForType(aType) {
-    if (this.metaBackend && (aType === META_NODE_TYPE || aType === META_EDGE_TYPE)) {
-      return this.metaBackend;
-    }
-    return this.backend;
-  }
-  getCombinedRegistry() {
-    if (!this.dynamicConfig) return this.staticRegistry;
-    return this.dynamicRegistry ?? this.staticRegistry ?? this.bootstrapRegistry;
-  }
-  // ---------------------------------------------------------------------------
-  // Query safety
-  // ---------------------------------------------------------------------------
-  checkQuerySafety(filters, allowCollectionScan) {
-    if (allowCollectionScan || this.scanProtection === "off") return;
-    const result = analyzeQuerySafety(filters);
-    if (result.safe) return;
-    if (this.scanProtection === "error") {
-      throw new QuerySafetyError(result.reason);
-    }
-    console.warn(`[firegraph] Query safety warning: ${result.reason}`);
-  }
-  // ---------------------------------------------------------------------------
-  // Migration helpers
-  // ---------------------------------------------------------------------------
-  async applyMigration(record, docId) {
-    const registry = this.getCombinedRegistry();
-    if (!registry) return record;
-    const result = await migrateRecord(record, registry, this.globalWriteBack);
-    if (result.migrated) {
-      this.handleWriteBack(result, docId);
-    }
-    return result.record;
-  }
-  async applyMigrations(records) {
-    const registry = this.getCombinedRegistry();
-    if (!registry || records.length === 0) return records;
-    const results = await migrateRecords(records, registry, this.globalWriteBack);
-    for (const result of results) {
-      if (result.migrated) {
-        const docId = result.record.axbType === NODE_RELATION ? computeNodeDocId(result.record.aUid) : computeEdgeDocId(result.record.aUid, result.record.axbType, result.record.bUid);
-        this.handleWriteBack(result, docId);
-      }
-    }
-    return results.map((r) => r.record);
-  }
-  /**
-   * Fire-and-forget write-back for a migrated record. Both `'eager'` and
-   * `'background'` are non-blocking; the difference is the log level on
-   * failure. For synchronous write-back, use a transaction — see
-   * `GraphTransactionImpl`.
-   */
-  handleWriteBack(result, docId) {
-    if (result.writeBack === "off") return;
-    const doWriteBack = async () => {
-      try {
-        await this.backend.updateDoc(docId, {
-          replaceData: result.record.data,
-          v: result.record.v
-        });
-      } catch (err) {
-        const msg = `[firegraph] Migration write-back failed for ${docId}: ${err.message}`;
-        if (result.writeBack === "eager") {
-          console.error(msg);
-        } else {
-          console.warn(msg);
-        }
-      }
-    };
-    void doWriteBack();
-  }
-  // ---------------------------------------------------------------------------
-  // GraphReader
-  // ---------------------------------------------------------------------------
-  async getNode(uid) {
-    const docId = computeNodeDocId(uid);
-    const record = await this.backend.getDoc(docId);
-    if (!record) return null;
-    return this.applyMigration(record, docId);
-  }
-  async getEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = await this.backend.getDoc(docId);
-    if (!record) return null;
-    return this.applyMigration(record, docId);
+    return result.record;
   }
   async edgeExists(aUid, axbType, bUid) {
     const docId = computeEdgeDocId(aUid, axbType, bUid);
     const record = await this.backend.getDoc(docId);
     return record !== null;
   }
+  checkQuerySafety(filters, allowCollectionScan) {
+    if (allowCollectionScan || this.scanProtection === "off") return;
+    const result = analyzeQuerySafety(filters);
+    if (result.safe) return;
+    if (this.scanProtection === "error") {
+      throw new QuerySafetyError(result.reason);
+    }
+    console.warn(`[firegraph] Query safety warning: ${result.reason}`);
+  }
   async findEdges(params) {
     const plan = buildEdgeQueryPlan(params);
     let records;
@@ -1396,40 +1829,47 @@ var GraphClientImpl = class _GraphClientImpl {
     }
     return this.applyMigrations(records);
   }
-  // ---------------------------------------------------------------------------
-  // GraphWriter
-  // ---------------------------------------------------------------------------
+  async applyMigrations(records) {
+    if (!this.registry || records.length === 0) return records;
+    const results = await migrateRecords(records, this.registry, this.globalWriteBack);
+    for (const result of results) {
+      if (result.migrated && result.writeBack !== "off") {
+        const docId = result.record.axbType === NODE_RELATION ? computeNodeDocId(result.record.aUid) : computeEdgeDocId(result.record.aUid, result.record.axbType, result.record.bUid);
+        await this.backend.updateDoc(docId, {
+          replaceData: result.record.data,
+          v: result.record.v
+        });
+      }
+    }
+    return results.map((r) => r.record);
+  }
   async putNode(aType, uid, data) {
-    const registry = this.getRegistryForType(aType);
-    if (registry) {
-      registry.validate(aType, NODE_RELATION, aType, data, this.backend.scopePath);
+    if (this.registry) {
+      this.registry.validate(aType, NODE_RELATION, aType, data, this.scopePath);
     }
-    const backend = this.getBackendForType(aType);
     const docId = computeNodeDocId(uid);
-    const record = buildWritableNodeRecord3(aType, uid, data);
-    if (registry) {
-      const entry = registry.lookup(aType, NODE_RELATION, aType);
+    const record = buildWritableNodeRecord2(aType, uid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
       if (entry?.schemaVersion && entry.schemaVersion > 0) {
         record.v = entry.schemaVersion;
       }
     }
-    await backend.setDoc(docId, record);
+    await this.backend.setDoc(docId, record);
   }
   async putEdge(aType, aUid, axbType, bType, bUid, data) {
-    const registry = this.getRegistryForType(aType);
-    if (registry) {
-      registry.validate(aType, axbType, bType, data, this.backend.scopePath);
+    if (this.registry) {
+      this.registry.validate(aType, axbType, bType, data, this.scopePath);
     }
-    const backend = this.getBackendForType(aType);
     const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = buildWritableEdgeRecord3(aType, aUid, axbType, bType, bUid, data);
-    if (registry) {
-      const entry = registry.lookup(aType, axbType, bType);
+    const record = buildWritableEdgeRecord2(aType, aUid, axbType, bType, bUid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, axbType, bType);
       if (entry?.schemaVersion && entry.schemaVersion > 0) {
         record.v = entry.schemaVersion;
       }
     }
-    await backend.setDoc(docId, record);
+    await this.backend.setDoc(docId, record);
   }
   async updateNode(uid, data) {
     const docId = computeNodeDocId(uid);
@@ -1443,982 +1883,779 @@ var GraphClientImpl = class _GraphClientImpl {
     const docId = computeEdgeDocId(aUid, axbType, bUid);
     await this.backend.deleteDoc(docId);
   }
-  // ---------------------------------------------------------------------------
-  // Transactions & Batches
-  // ---------------------------------------------------------------------------
-  async runTransaction(fn) {
-    return this.backend.runTransaction(async (txBackend) => {
-      const graphTx = new GraphTransactionImpl(
-        txBackend,
-        this.getCombinedRegistry(),
-        this.scanProtection,
-        this.backend.scopePath,
-        this.globalWriteBack
-      );
-      return fn(graphTx);
-    });
-  }
-  batch() {
-    return new GraphBatchImpl(
-      this.backend.createBatch(),
-      this.getCombinedRegistry(),
-      this.backend.scopePath
-    );
-  }
-  // ---------------------------------------------------------------------------
-  // Subgraph
-  // ---------------------------------------------------------------------------
-  subgraph(parentNodeUid, name = "graph") {
-    if (!parentNodeUid || parentNodeUid.includes("/")) {
-      throw new FiregraphError(
-        `Invalid parentNodeUid for subgraph: "${parentNodeUid}". Must be a non-empty string without "/".`,
-        "INVALID_SUBGRAPH"
-      );
-    }
-    if (name.includes("/")) {
-      throw new FiregraphError(
-        `Subgraph name must not contain "/": got "${name}". Use chained .subgraph() calls for nested subgraphs.`,
-        "INVALID_SUBGRAPH"
-      );
-    }
-    const childBackend = this.backend.subgraph(parentNodeUid, name);
-    return new _GraphClientImpl(
-      childBackend,
-      {
-        registry: this.getCombinedRegistry(),
-        scanProtection: this.scanProtection,
-        migrationWriteBack: this.globalWriteBack,
-        migrationSandbox: this.migrationSandbox
+};
+
+// src/client.ts
+var RESERVED_TYPE_NAMES = /* @__PURE__ */ new Set([META_NODE_TYPE, META_EDGE_TYPE]);
+function buildWritableNodeRecord3(aType, uid, data) {
+  return { aType, aUid: uid, axbType: NODE_RELATION, bType: aType, bUid: uid, data };
+}
+function buildWritableEdgeRecord3(aType, aUid, axbType, bType, bUid, data) {
+  return { aType, aUid, axbType, bType, bUid, data };
+}
+var GraphClientImpl = class _GraphClientImpl {
+  constructor(backend, options, metaBackend) {
+    this.backend = backend;
+    this.globalWriteBack = options?.migrationWriteBack ?? "off";
+    this.migrationSandbox = options?.migrationSandbox;
+    if (options?.registryMode) {
+      this.dynamicConfig = options.registryMode;
+      this.bootstrapRegistry = createBootstrapRegistry();
+      if (options.registry) {
+        this.staticRegistry = options.registry;
       }
-      // Subgraphs do not have meta-backends; meta lives only at the root.
-    );
-  }
-  // ---------------------------------------------------------------------------
-  // Collection group query
-  // ---------------------------------------------------------------------------
-  async findEdgesGlobal(params, collectionName) {
-    if (!this.backend.findEdgesGlobal) {
-      throw new FiregraphError(
-        "findEdgesGlobal() is not supported by the current storage backend.",
-        "UNSUPPORTED_OPERATION"
-      );
-    }
-    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"
-      );
+      this.metaBackend = metaBackend;
+    } else {
+      this.staticRegistry = options?.registry;
     }
-    this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-    const records = await this.backend.findEdgesGlobal(params, collectionName);
-    return this.applyMigrations(records);
+    this.scanProtection = options?.scanProtection ?? "error";
   }
+  scanProtection;
+  // Static mode
+  staticRegistry;
+  // Dynamic mode
+  dynamicConfig;
+  bootstrapRegistry;
+  dynamicRegistry;
+  metaBackend;
+  // Migration settings
+  globalWriteBack;
+  migrationSandbox;
   // ---------------------------------------------------------------------------
-  // Bulk operations
+  // Backend access (exposed for traversal helpers and subgraph cloning)
   // ---------------------------------------------------------------------------
-  async removeNodeCascade(uid, options) {
-    return this.backend.removeNodeCascade(uid, this, options);
+  /** @internal */
+  getBackend() {
+    return this.backend;
   }
-  async bulkRemoveEdges(params, options) {
-    return this.backend.bulkRemoveEdges(params, this, options);
+  /**
+   * Snapshot of the currently-effective registry. Returns the merged view
+   * used for domain-type validation and migration — in dynamic mode this is
+   * `dynamicRegistry ?? staticRegistry ?? bootstrapRegistry`, so callers see
+   * updates after `reloadRegistry()` without having to re-resolve anything.
+   *
+   * Exposed for backends that need topology access during bulk operations
+   * (e.g. the Cloudflare DO backend's cross-DO cascade). Not part of the
+   * public `GraphClient` surface.
+   *
+   * @internal
+   */
+  getRegistrySnapshot() {
+    return this.getCombinedRegistry();
   }
   // ---------------------------------------------------------------------------
-  // Dynamic registry methods
+  // Registry routing
   // ---------------------------------------------------------------------------
-  async defineNodeType(name, jsonSchema, description, options) {
-    if (!this.dynamicConfig) {
-      throw new DynamicRegistryError(
-        'defineNodeType() is only available in dynamic registry mode. Pass registryMode: { mode: "dynamic" } to createGraphClient().'
-      );
-    }
-    if (RESERVED_TYPE_NAMES.has(name)) {
-      throw new DynamicRegistryError(
-        `Cannot define type "${name}": this name is reserved for the meta-registry.`
-      );
-    }
-    if (this.staticRegistry?.lookup(name, NODE_RELATION, name)) {
-      throw new DynamicRegistryError(
-        `Cannot define node type "${name}": already defined in the static registry.`
-      );
-    }
-    const uid = generateDeterministicUid(META_NODE_TYPE, name);
-    const data = { name, jsonSchema };
-    if (description !== void 0) data.description = description;
-    if (options?.titleField !== void 0) data.titleField = options.titleField;
-    if (options?.subtitleField !== void 0) data.subtitleField = options.subtitleField;
-    if (options?.viewTemplate !== void 0) data.viewTemplate = options.viewTemplate;
-    if (options?.viewCss !== void 0) data.viewCss = options.viewCss;
-    if (options?.allowedIn !== void 0) data.allowedIn = options.allowedIn;
-    if (options?.migrationWriteBack !== void 0)
-      data.migrationWriteBack = options.migrationWriteBack;
-    if (options?.migrations !== void 0) {
-      data.migrations = await this.serializeMigrations(options.migrations);
+  getRegistryForType(aType) {
+    if (!this.dynamicConfig) return this.staticRegistry;
+    if (aType === META_NODE_TYPE || aType === META_EDGE_TYPE) {
+      return this.bootstrapRegistry;
     }
-    await this.putNode(META_NODE_TYPE, uid, data);
+    return this.dynamicRegistry ?? this.staticRegistry ?? this.bootstrapRegistry;
   }
-  async defineEdgeType(name, topology, jsonSchema, description, options) {
-    if (!this.dynamicConfig) {
-      throw new DynamicRegistryError(
-        'defineEdgeType() is only available in dynamic registry mode. Pass registryMode: { mode: "dynamic" } to createGraphClient().'
-      );
-    }
-    if (RESERVED_TYPE_NAMES.has(name)) {
-      throw new DynamicRegistryError(
-        `Cannot define type "${name}": this name is reserved for the meta-registry.`
-      );
-    }
-    if (this.staticRegistry) {
-      const fromTypes = Array.isArray(topology.from) ? topology.from : [topology.from];
-      const toTypes = Array.isArray(topology.to) ? topology.to : [topology.to];
-      for (const aType of fromTypes) {
-        for (const bType of toTypes) {
-          if (this.staticRegistry.lookup(aType, name, bType)) {
-            throw new DynamicRegistryError(
-              `Cannot define edge type "${name}" for (${aType}) -> (${bType}): already defined in the static registry.`
-            );
-          }
-        }
-      }
-    }
-    const uid = generateDeterministicUid(META_EDGE_TYPE, name);
-    const data = {
-      name,
-      from: topology.from,
-      to: topology.to
-    };
-    if (jsonSchema !== void 0) data.jsonSchema = jsonSchema;
-    if (topology.inverseLabel !== void 0) data.inverseLabel = topology.inverseLabel;
-    if (topology.targetGraph !== void 0) data.targetGraph = topology.targetGraph;
-    if (description !== void 0) data.description = description;
-    if (options?.titleField !== void 0) data.titleField = options.titleField;
-    if (options?.subtitleField !== void 0) data.subtitleField = options.subtitleField;
-    if (options?.viewTemplate !== void 0) data.viewTemplate = options.viewTemplate;
-    if (options?.viewCss !== void 0) data.viewCss = options.viewCss;
-    if (options?.allowedIn !== void 0) data.allowedIn = options.allowedIn;
-    if (options?.migrationWriteBack !== void 0)
-      data.migrationWriteBack = options.migrationWriteBack;
-    if (options?.migrations !== void 0) {
-      data.migrations = await this.serializeMigrations(options.migrations);
+  getBackendForType(aType) {
+    if (this.metaBackend && (aType === META_NODE_TYPE || aType === META_EDGE_TYPE)) {
+      return this.metaBackend;
     }
-    await this.putNode(META_EDGE_TYPE, uid, data);
+    return this.backend;
+  }
+  getCombinedRegistry() {
+    if (!this.dynamicConfig) return this.staticRegistry;
+    return this.dynamicRegistry ?? this.staticRegistry ?? this.bootstrapRegistry;
   }
-  async reloadRegistry() {
-    if (!this.dynamicConfig) {
-      throw new DynamicRegistryError(
-        'reloadRegistry() is only available in dynamic registry mode. Pass registryMode: { mode: "dynamic" } to createGraphClient().'
-      );
+  // ---------------------------------------------------------------------------
+  // Query safety
+  // ---------------------------------------------------------------------------
+  checkQuerySafety(filters, allowCollectionScan) {
+    if (allowCollectionScan || this.scanProtection === "off") return;
+    const result = analyzeQuerySafety(filters);
+    if (result.safe) return;
+    if (this.scanProtection === "error") {
+      throw new QuerySafetyError(result.reason);
     }
-    const reader = this.createMetaReader();
-    const dynamicOnly = await createRegistryFromGraph(reader, this.migrationSandbox);
-    if (this.staticRegistry) {
-      this.dynamicRegistry = createMergedRegistry(this.staticRegistry, dynamicOnly);
-    } else {
-      this.dynamicRegistry = dynamicOnly;
+    console.warn(`[firegraph] Query safety warning: ${result.reason}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Migration helpers
+  // ---------------------------------------------------------------------------
+  async applyMigration(record, docId) {
+    const registry = this.getCombinedRegistry();
+    if (!registry) return record;
+    const result = await migrateRecord(record, registry, this.globalWriteBack);
+    if (result.migrated) {
+      this.handleWriteBack(result, docId);
     }
+    return result.record;
   }
-  async serializeMigrations(migrations) {
-    const result = migrations.map((m) => {
-      const source = typeof m.up === "function" ? m.up.toString() : m.up;
-      return { fromVersion: m.fromVersion, toVersion: m.toVersion, up: source };
-    });
-    await Promise.all(result.map((m) => precompileSource(m.up, this.migrationSandbox)));
-    return result;
+  async applyMigrations(records) {
+    const registry = this.getCombinedRegistry();
+    if (!registry || records.length === 0) return records;
+    const results = await migrateRecords(records, registry, this.globalWriteBack);
+    for (const result of results) {
+      if (result.migrated) {
+        const docId = result.record.axbType === NODE_RELATION ? computeNodeDocId(result.record.aUid) : computeEdgeDocId(result.record.aUid, result.record.axbType, result.record.bUid);
+        this.handleWriteBack(result, docId);
+      }
+    }
+    return results.map((r) => r.record);
   }
   /**
-   * Build a `GraphReader` over the meta-backend. If meta lives in the same
-   * collection as the main backend, `this` is returned directly.
+   * Fire-and-forget write-back for a migrated record. Both `'eager'` and
+   * `'background'` are non-blocking; the difference is the log level on
+   * failure. For synchronous write-back, use a transaction — see
+   * `GraphTransactionImpl`.
    */
-  createMetaReader() {
-    if (!this.metaBackend) return this;
-    const backend = this.metaBackend;
-    const executeMetaQuery = (filters, options) => backend.query(filters, options);
-    return {
-      async getNode(uid) {
-        return backend.getDoc(computeNodeDocId(uid));
-      },
-      async getEdge(aUid, axbType, bUid) {
-        return backend.getDoc(computeEdgeDocId(aUid, axbType, bUid));
-      },
-      async edgeExists(aUid, axbType, bUid) {
-        const record = await backend.getDoc(computeEdgeDocId(aUid, axbType, bUid));
-        return record !== null;
-      },
-      async findEdges(params) {
-        const plan = buildEdgeQueryPlan(params);
-        if (plan.strategy === "get") {
-          const record = await backend.getDoc(plan.docId);
-          return record ? [record] : [];
-        }
-        return executeMetaQuery(plan.filters, plan.options);
-      },
-      async findNodes(params) {
-        const plan = buildNodeQueryPlan(params);
-        if (plan.strategy === "get") {
-          const record = await backend.getDoc(plan.docId);
-          return record ? [record] : [];
+  handleWriteBack(result, docId) {
+    if (result.writeBack === "off") return;
+    const doWriteBack = async () => {
+      try {
+        await this.backend.updateDoc(docId, {
+          replaceData: result.record.data,
+          v: result.record.v
+        });
+      } catch (err) {
+        const msg = `[firegraph] Migration write-back failed for ${docId}: ${err.message}`;
+        if (result.writeBack === "eager") {
+          console.error(msg);
+        } else {
+          console.warn(msg);
         }
-        return executeMetaQuery(plan.filters, plan.options);
       }
     };
+    void doWriteBack();
   }
-};
-function createGraphClientFromBackend(backend, options, metaBackend) {
-  return new GraphClientImpl(backend, options, metaBackend);
-}
-
-// src/timestamp.ts
-var GraphTimestampImpl = class _GraphTimestampImpl {
-  constructor(seconds, nanoseconds) {
-    this.seconds = seconds;
-    this.nanoseconds = nanoseconds;
-  }
-  toDate() {
-    return new Date(this.toMillis());
+  // ---------------------------------------------------------------------------
+  // GraphReader
+  // ---------------------------------------------------------------------------
+  async getNode(uid) {
+    const docId = computeNodeDocId(uid);
+    const record = await this.backend.getDoc(docId);
+    if (!record) return null;
+    return this.applyMigration(record, docId);
   }
-  toMillis() {
-    return this.seconds * 1e3 + Math.floor(this.nanoseconds / 1e6);
+  async getEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record = await this.backend.getDoc(docId);
+    if (!record) return null;
+    return this.applyMigration(record, docId);
   }
-  toJSON() {
-    return { seconds: this.seconds, nanoseconds: this.nanoseconds };
+  async edgeExists(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record = await this.backend.getDoc(docId);
+    return record !== null;
   }
-  static fromMillis(ms) {
-    const seconds = Math.floor(ms / 1e3);
-    const nanoseconds = (ms - seconds * 1e3) * 1e6;
-    return new _GraphTimestampImpl(seconds, nanoseconds);
+  async findEdges(params) {
+    const plan = buildEdgeQueryPlan(params);
+    let records;
+    if (plan.strategy === "get") {
+      const record = await this.backend.getDoc(plan.docId);
+      records = record ? [record] : [];
+    } else {
+      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
+      records = await this.backend.query(plan.filters, plan.options);
+    }
+    return this.applyMigrations(records);
   }
-  static now() {
-    return _GraphTimestampImpl.fromMillis(Date.now());
+  async findNodes(params) {
+    const plan = buildNodeQueryPlan(params);
+    let records;
+    if (plan.strategy === "get") {
+      const record = await this.backend.getDoc(plan.docId);
+      records = record ? [record] : [];
+    } else {
+      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
+      records = await this.backend.query(plan.filters, plan.options);
+    }
+    return this.applyMigrations(records);
   }
-};
-
-// 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_]*$/.`);
+  // ---------------------------------------------------------------------------
+  // GraphWriter
+  // ---------------------------------------------------------------------------
+  async putNode(aType, uid, data) {
+    const registry = this.getRegistryForType(aType);
+    if (registry) {
+      registry.validate(aType, NODE_RELATION, aType, data, this.backend.scopePath);
+    }
+    const backend = this.getBackendForType(aType);
+    const docId = computeNodeDocId(uid);
+    const record = buildWritableNodeRecord3(aType, uid, data);
+    if (registry) {
+      const entry = registry.lookup(aType, NODE_RELATION, aType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record.v = entry.schemaVersion;
+      }
+    }
+    await backend.setDoc(docId, record);
   }
-}
-
-// src/internal/sqlite-sql.ts
-function compileFieldRef(field) {
-  const column = FIELD_TO_COLUMN[field];
-  if (column) {
-    return { expr: quoteIdent(column) };
+  async putEdge(aType, aUid, axbType, bType, bUid, data) {
+    const registry = this.getRegistryForType(aType);
+    if (registry) {
+      registry.validate(aType, axbType, bType, data, this.backend.scopePath);
+    }
+    const backend = this.getBackendForType(aType);
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record = buildWritableEdgeRecord3(aType, aUid, axbType, bType, bUid, data);
+    if (registry) {
+      const entry = registry.lookup(aType, axbType, bType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record.v = entry.schemaVersion;
+      }
+    }
+    await backend.setDoc(docId, record);
   }
-  if (field.startsWith("data.")) {
-    const key = field.slice(5);
-    validateJsonPathKey(key);
-    return { expr: 'json_extract("data", ?)', pathParam: `$.${key}` };
+  async updateNode(uid, data) {
+    const docId = computeNodeDocId(uid);
+    await this.backend.updateDoc(docId, { dataFields: data });
   }
-  if (field === "data") {
-    return { expr: 'json_extract("data", ?)', pathParam: "$" };
+  async removeNode(uid) {
+    const docId = computeNodeDocId(uid);
+    await this.backend.deleteDoc(docId);
   }
-  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;
+  async removeEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    await this.backend.deleteDoc(docId);
   }
-  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"
+  // ---------------------------------------------------------------------------
+  // Transactions & Batches
+  // ---------------------------------------------------------------------------
+  async runTransaction(fn) {
+    return this.backend.runTransaction(async (txBackend) => {
+      const graphTx = new GraphTransactionImpl(
+        txBackend,
+        this.getCombinedRegistry(),
+        this.scanProtection,
+        this.backend.scopePath,
+        this.globalWriteBack
       );
-    }
-    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"
-    );
+      return fn(graphTx);
+    });
   }
-  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"
+  batch() {
+    return new GraphBatchImpl(
+      this.backend.createBatch(),
+      this.getCombinedRegistry(),
+      this.backend.scopePath
     );
   }
-}
-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})`;
+  // ---------------------------------------------------------------------------
+  // Subgraph
+  // ---------------------------------------------------------------------------
+  subgraph(parentNodeUid, name = "graph") {
+    if (!parentNodeUid || parentNodeUid.includes("/")) {
+      throw new FiregraphError(
+        `Invalid parentNodeUid for subgraph: "${parentNodeUid}". Must be a non-empty string without "/".`,
+        "INVALID_SUBGRAPH"
+      );
     }
-    case "array-contains": {
-      params.push(bindValue(filter.value));
-      return `EXISTS (SELECT 1 FROM json_each(${expr}) WHERE value = ?)`;
+    if (name.includes("/")) {
+      throw new FiregraphError(
+        `Subgraph name must not contain "/": got "${name}". Use chained .subgraph() calls for nested subgraphs.`,
+        "INVALID_SUBGRAPH"
+      );
     }
-    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}))`;
+    const childBackend = this.backend.subgraph(parentNodeUid, name);
+    return new _GraphClientImpl(
+      childBackend,
+      {
+        registry: this.getCombinedRegistry(),
+        scanProtection: this.scanProtection,
+        migrationWriteBack: this.globalWriteBack,
+        migrationSandbox: this.migrationSandbox
+      }
+      // Subgraphs do not have meta-backends; meta lives only at the root.
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Collection group query
+  // ---------------------------------------------------------------------------
+  async findEdgesGlobal(params, collectionName) {
+    if (!this.backend.findEdgesGlobal) {
+      throw new FiregraphError(
+        "findEdgesGlobal() is not supported by the current storage backend.",
+        "UNSUPPORTED_OPERATION"
+      );
     }
-    default:
+    const plan = buildEdgeQueryPlan(params);
+    if (plan.strategy === "get") {
       throw new FiregraphError(
-        `SQLite backend does not support filter operator: ${String(filter.op)}`,
+        "findEdgesGlobal() requires a query, not a direct document lookup. Omit one of aUid/axbType/bUid to force a query strategy.",
         "INVALID_QUERY"
       );
+    }
+    this.checkQuerySafety(plan.filters, params.allowCollectionScan);
+    const records = await this.backend.findEdgesGlobal(params, collectionName);
+    return this.applyMigrations(records);
   }
-}
-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));
+  // ---------------------------------------------------------------------------
+  // Bulk operations
+  // ---------------------------------------------------------------------------
+  async removeNodeCascade(uid, options) {
+    return this.backend.removeNodeCascade(uid, this, options);
   }
-  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"
-    );
+  async bulkRemoveEdges(params, options) {
+    return this.backend.bulkRemoveEdges(params, this, options);
   }
-  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)}`);
+  // ---------------------------------------------------------------------------
+  // Dynamic registry methods
+  // ---------------------------------------------------------------------------
+  async defineNodeType(name, jsonSchema, description, options) {
+    if (!this.dynamicConfig) {
+      throw new DynamicRegistryError(
+        'defineNodeType() is only available in dynamic registry mode. Pass registryMode: { mode: "dynamic" } to createGraphClient().'
+      );
     }
+    if (RESERVED_TYPE_NAMES.has(name)) {
+      throw new DynamicRegistryError(
+        `Cannot define type "${name}": this name is reserved for the meta-registry.`
+      );
+    }
+    if (this.staticRegistry?.lookup(name, NODE_RELATION, name)) {
+      throw new DynamicRegistryError(
+        `Cannot define node type "${name}": already defined in the static registry.`
+      );
+    }
+    const uid = generateDeterministicUid(META_NODE_TYPE, name);
+    const data = { name, jsonSchema };
+    if (description !== void 0) data.description = description;
+    if (options?.titleField !== void 0) data.titleField = options.titleField;
+    if (options?.subtitleField !== void 0) data.subtitleField = options.subtitleField;
+    if (options?.viewTemplate !== void 0) data.viewTemplate = options.viewTemplate;
+    if (options?.viewCss !== void 0) data.viewCss = options.viewCss;
+    if (options?.allowedIn !== void 0) data.allowedIn = options.allowedIn;
+    if (options?.migrationWriteBack !== void 0)
+      data.migrationWriteBack = options.migrationWriteBack;
+    if (options?.migrations !== void 0) {
+      data.migrations = await this.serializeMigrations(options.migrations);
+    }
+    await this.putNode(META_NODE_TYPE, uid, data);
   }
-  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));
+  async defineEdgeType(name, topology, jsonSchema, description, options) {
+    if (!this.dynamicConfig) {
+      throw new DynamicRegistryError(
+        'defineEdgeType() is only available in dynamic registry mode. Pass registryMode: { mode: "dynamic" } to createGraphClient().'
+      );
+    }
+    if (RESERVED_TYPE_NAMES.has(name)) {
+      throw new DynamicRegistryError(
+        `Cannot define type "${name}": this name is reserved for the meta-registry.`
+      );
+    }
+    if (this.staticRegistry) {
+      const fromTypes = Array.isArray(topology.from) ? topology.from : [topology.from];
+      const toTypes = Array.isArray(topology.to) ? topology.to : [topology.to];
+      for (const aType of fromTypes) {
+        for (const bType of toTypes) {
+          if (this.staticRegistry.lookup(aType, name, bType)) {
+            throw new DynamicRegistryError(
+              `Cannot define edge type "${name}" for (${aType}) -> (${bType}): already defined in the static registry.`
+            );
+          }
+        }
+      }
+    }
+    const uid = generateDeterministicUid(META_EDGE_TYPE, name);
+    const data = {
+      name,
+      from: topology.from,
+      to: topology.to
+    };
+    if (jsonSchema !== void 0) data.jsonSchema = jsonSchema;
+    if (topology.inverseLabel !== void 0) data.inverseLabel = topology.inverseLabel;
+    if (topology.targetGraph !== void 0) data.targetGraph = topology.targetGraph;
+    if (description !== void 0) data.description = description;
+    if (options?.titleField !== void 0) data.titleField = options.titleField;
+    if (options?.subtitleField !== void 0) data.subtitleField = options.subtitleField;
+    if (options?.viewTemplate !== void 0) data.viewTemplate = options.viewTemplate;
+    if (options?.viewCss !== void 0) data.viewCss = options.viewCss;
+    if (options?.allowedIn !== void 0) data.allowedIn = options.allowedIn;
+    if (options?.migrationWriteBack !== void 0)
+      data.migrationWriteBack = options.migrationWriteBack;
+    if (options?.migrations !== void 0) {
+      data.migrations = await this.serializeMigrations(options.migrations);
     }
+    await this.putNode(META_EDGE_TYPE, uid, data);
   }
-  if (update.v !== void 0) {
-    setClauses.push(`"v" = ?`);
-    params.push(update.v);
+  async reloadRegistry() {
+    if (!this.dynamicConfig) {
+      throw new DynamicRegistryError(
+        'reloadRegistry() is only available in dynamic registry mode. Pass registryMode: { mode: "dynamic" } to createGraphClient().'
+      );
+    }
+    const reader = this.createMetaReader();
+    const dynamicOnly = await createRegistryFromGraph(reader, this.migrationSandbox);
+    if (this.staticRegistry) {
+      this.dynamicRegistry = createMergedRegistry(this.staticRegistry, dynamicOnly);
+    } else {
+      this.dynamicRegistry = dynamicOnly;
+    }
   }
-  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);
+  async serializeMigrations(migrations) {
+    const result = migrations.map((m) => {
+      const source = typeof m.up === "function" ? m.up.toString() : m.up;
+      return { fromVersion: m.fromVersion, toVersion: m.toVersion, up: source };
+    });
+    await Promise.all(result.map((m) => precompileSource(m.up, this.migrationSandbox)));
+    return result;
   }
-  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;
+  /**
+   * Build a `GraphReader` over the meta-backend. If meta lives in the same
+   * collection as the main backend, `this` is returned directly.
+   */
+  createMetaReader() {
+    if (!this.metaBackend) return this;
+    const backend = this.metaBackend;
+    const executeMetaQuery = (filters, options) => backend.query(filters, options);
+    return {
+      async getNode(uid) {
+        return backend.getDoc(computeNodeDocId(uid));
+      },
+      async getEdge(aUid, axbType, bUid) {
+        return backend.getDoc(computeEdgeDocId(aUid, axbType, bUid));
+      },
+      async edgeExists(aUid, axbType, bUid) {
+        const record = await backend.getDoc(computeEdgeDocId(aUid, axbType, bUid));
+        return record !== null;
+      },
+      async findEdges(params) {
+        const plan = buildEdgeQueryPlan(params);
+        if (plan.strategy === "get") {
+          const record = await backend.getDoc(plan.docId);
+          return record ? [record] : [];
+        }
+        return executeMetaQuery(plan.filters, plan.options);
+      },
+      async findNodes(params) {
+        const plan = buildNodeQueryPlan(params);
+        if (plan.strategy === "get") {
+          const record = await backend.getDoc(plan.docId);
+          return record ? [record] : [];
+        }
+        return executeMetaQuery(plan.filters, plan.options);
+      }
+    };
+  }
+};
+function createGraphClientFromBackend(backend, options, metaBackend) {
+  return new GraphClientImpl(backend, options, metaBackend);
 }
 
-// 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);
+// src/cloudflare/client.ts
+function createDOClient(namespace, rootKey, options = {}) {
+  if (!rootKey || typeof rootKey !== "string") {
+    throw new FiregraphError(
+      `createDOClient: rootKey must be a non-empty string, got ${JSON.stringify(rootKey)}.`,
+      "INVALID_ARGUMENT"
+    );
   }
-  async setDoc(docId, record) {
-    const stmt = compileSet(this.tableName, this.storageScope, docId, record, Date.now());
-    await this.tx.run(stmt.sql, stmt.params);
+  if (rootKey.includes("/")) {
+    throw new FiregraphError(
+      `createDOClient: rootKey must not contain "/". Got: "${rootKey}".`,
+      "INVALID_ARGUMENT"
+    );
   }
-  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) {
+  let client;
+  const registryAccessor = () => {
+    if (!client) {
       throw new FiregraphError(
-        `updateDoc: no document found for doc_id=${docId} (scope=${this.storageScope})`,
-        "NOT_FOUND"
+        "createDOClient: registryAccessor fired before the client was assigned. This indicates a programming error in the DO backend \u2014 the accessor must only be invoked lazily from `removeNodeCascade`, never synchronously from the `DORPCBackend` constructor.",
+        "INTERNAL"
       );
     }
+    return client.getRegistrySnapshot();
+  };
+  const siblingOptions = { ...options };
+  const makeSiblingClient = (siblingRootKey) => createDOClient(namespace, siblingRootKey, siblingOptions);
+  const backend = new DORPCBackend(namespace, {
+    scopePath: "",
+    storageKey: rootKey,
+    registryAccessor,
+    makeSiblingClient
+  });
+  let metaBackend;
+  if (options.registryMode?.collection) {
+    const metaKey = options.registryMode.collection;
+    if (metaKey.includes("/")) {
+      throw new FiregraphError(
+        `createDOClient: registryMode.collection must not contain "/". Got: "${metaKey}".`,
+        "INVALID_ARGUMENT"
+      );
+    }
+    if (metaKey !== rootKey) {
+      metaBackend = new DORPCBackend(namespace, {
+        scopePath: "",
+        storageKey: metaKey,
+        // Meta backend shares the accessor so its own `removeNodeCascade`
+        // (unlikely, but safe) would also see the live registry. Sibling
+        // factory is carried for consistency; there's no user-facing path
+        // that creates a sibling from the meta backend, but it costs
+        // nothing to keep the two backends in sync.
+        registryAccessor,
+        makeSiblingClient
+      });
+    }
   }
-  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())
+  client = createGraphClientFromBackend(backend, options, metaBackend);
+  return client;
+}
+function createSiblingClient(client, siblingRootKey) {
+  if (!siblingRootKey || typeof siblingRootKey !== "string") {
+    throw new FiregraphError(
+      `createSiblingClient: siblingRootKey must be a non-empty string, got ${JSON.stringify(siblingRootKey)}.`,
+      "INVALID_ARGUMENT"
     );
   }
-  deleteDoc(docId) {
-    this.statements.push(compileDelete(this.tableName, this.storageScope, docId));
+  if (siblingRootKey.includes("/")) {
+    throw new FiregraphError(
+      `createSiblingClient: siblingRootKey must not contain "/". Got: "${siblingRootKey}".`,
+      "INVALID_ARGUMENT"
+    );
   }
-  async commit() {
-    if (this.statements.length === 0) return;
-    await this.executor.batch(this.statements);
-    this.statements.length = 0;
+  const impl = client;
+  const backend = typeof impl.getBackend === "function" ? impl.getBackend() : void 0;
+  const maker = backend && backend.makeSiblingClient;
+  if (typeof maker !== "function") {
+    throw new FiregraphError(
+      "createSiblingClient: the provided client is not backed by a DO client produced by `createDOClient`. Sibling construction is only available for DO-backed clients.",
+      "UNSUPPORTED_OPERATION"
+    );
   }
+  return maker(siblingRootKey);
+}
+
+// src/cloudflare/do.ts
+var DEFAULT_OPTIONS = {
+  table: "firegraph",
+  autoMigrate: true
 };
-var SqliteBackendImpl = class _SqliteBackendImpl {
-  constructor(executor, tableName, storageScope, scopePath) {
-    this.executor = executor;
-    this.collectionPath = tableName;
-    this.storageScope = storageScope;
-    this.scopePath = scopePath;
+var FiregraphDO = class {
+  /** @internal — exposed for subclass access, not part of the public RPC. */
+  ctx;
+  /** @internal — exposed for subclass access; opaque to this class. */
+  env;
+  /** @internal — table name used by every compiled statement. */
+  table;
+  /** @internal — registry consulted by `runSchema` for per-entry indexes. */
+  registry;
+  /** @internal — overrides `DEFAULT_CORE_INDEXES` when set. */
+  coreIndexes;
+  constructor(ctx, env, options = {}) {
+    this.ctx = ctx;
+    this.env = env;
+    const table = options.table ?? DEFAULT_OPTIONS.table;
+    validateDOTableName(table);
+    this.table = table;
+    this.registry = options.registry;
+    this.coreIndexes = options.coreIndexes;
+    const autoMigrate = options.autoMigrate ?? DEFAULT_OPTIONS.autoMigrate;
+    if (autoMigrate) {
+      void this.ctx.blockConcurrencyWhile(async () => {
+        this.runSchema();
+      });
+    }
   }
-  /** 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]);
+  // ---------------------------------------------------------------------------
+  // RPC: reads
+  //
+  // Method names are prefixed `_fg` so user subclasses can add their own RPC
+  // methods without name collisions. The client-side backend in
+  // `src/cloudflare/backend.ts` calls these directly on the DO stub.
+  // ---------------------------------------------------------------------------
+  async _fgGetDoc(docId) {
+    const stmt = compileDOSelectByDocId(this.table, docId);
+    const rows = this.execAll(stmt);
+    return rows.length === 0 ? null : rowToDORecord(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);
+  async _fgQuery(filters, options) {
+    const stmt = compileDOSelect(this.table, filters, options);
+    const rows = this.execAll(stmt);
+    return rows.map(rowToDORecord);
   }
-  // --- Writes ---
-  async setDoc(docId, record) {
-    const stmt = compileSet(this.collectionPath, this.storageScope, docId, record, Date.now());
-    await this.executor.run(stmt.sql, stmt.params);
+  // ---------------------------------------------------------------------------
+  // RPC: writes
+  // ---------------------------------------------------------------------------
+  async _fgSetDoc(docId, record) {
+    const stmt = compileDOSet(this.table, docId, record, Date.now());
+    this.execRun(stmt);
   }
-  async updateDoc(docId, update) {
-    const stmt = compileUpdate(this.collectionPath, this.storageScope, docId, update, Date.now());
+  async _fgUpdateDoc(docId, update) {
+    const stmt = compileDOUpdate(this.table, docId, update, Date.now());
     const sqlWithReturning = `${stmt.sql} RETURNING "doc_id"`;
-    const rows = await this.executor.all(sqlWithReturning, stmt.params);
+    const rows = this.ctx.storage.sql.exec(sqlWithReturning, ...stmt.params).toArray();
     if (rows.length === 0) {
-      throw new FiregraphError(
-        `updateDoc: no document found for doc_id=${docId} (scope=${this.storageScope})`,
-        "NOT_FOUND"
-      );
+      throw new FiregraphError(`updateDoc: no document found for doc_id=${docId}`, "NOT_FOUND");
     }
   }
-  async deleteDoc(docId) {
-    const stmt = compileDelete(this.collectionPath, this.storageScope, docId);
-    await this.executor.run(stmt.sql, stmt.params);
+  async _fgDeleteDoc(docId) {
+    const stmt = compileDODelete(this.table, docId);
+    this.execRun(stmt);
   }
-  // --- 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);
+  // ---------------------------------------------------------------------------
+  // RPC: batch
+  // ---------------------------------------------------------------------------
+  /**
+   * Execute a list of write ops atomically. DO SQLite's `transactionSync`
+   * provides real atomicity — either every statement commits or none do.
+   * No statement-count cap applies (contrast with D1's ~100-statement batch
+   * limit), so the caller can submit as many ops as they like in one call.
+   */
+  async _fgBatch(ops) {
+    if (ops.length === 0) return;
+    const now = Date.now();
+    const statements = ops.map((op) => {
+      switch (op.kind) {
+        case "set":
+          return compileDOSet(this.table, op.docId, op.record, now);
+        case "update":
+          return compileDOUpdate(this.table, op.docId, op.update, now);
+        case "delete":
+          return compileDODelete(this.table, op.docId);
+      }
+    });
+    this.ctx.storage.transactionSync(() => {
+      for (const stmt of statements) {
+        this.ctx.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
+      }
     });
   }
-  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 })
-    ]);
+  // ---------------------------------------------------------------------------
+  // RPC: cascade + bulk (local DO only)
+  //
+  // These cascade *within this DO*. Subgraph DOs (nested under this node) are
+  // not reachable from here — the client-side `DORPCBackend.removeNodeCascade`
+  // consults the registry topology to discover descendant subgraph DOs and
+  // fans out explicit `_fgDestroy` calls to each before invoking this method.
+  // Without that topology the DO has no way to enumerate its children.
+  // ---------------------------------------------------------------------------
+  async _fgRemoveNodeCascade(uid) {
+    const outgoingStmt = compileDOSelect(this.table, [{ field: "aUid", op: "==", value: uid }]);
+    const incomingStmt = compileDOSelect(this.table, [{ field: "bUid", op: "==", value: uid }]);
+    const outgoingRows = this.execAll(outgoingStmt);
+    const incomingRows = this.execAll(incomingStmt);
     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);
+    let nodeExists = false;
+    for (const row of [...outgoingRows, ...incomingRows]) {
+      const axbType = row.axb_type;
+      const aUid = row.a_uid;
+      const bUid = row.b_uid;
+      if (axbType === NODE_RELATION && aUid === bUid) {
+        nodeExists = true;
+        continue;
+      }
+      const docId = computeEdgeDocId(aUid, axbType, 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 = edgeDocIds.map((id) => compileDODelete(this.table, id));
+    if (nodeExists) {
+      statements.push(compileDODelete(this.table, computeNodeDocId(uid)));
     }
-    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: [] };
+      return {
+        deleted: 0,
+        batches: 0,
+        errors: [],
+        edgesDeleted: 0,
+        nodeDeleted: false
+      };
     }
-    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);
-          }
+    try {
+      this.ctx.storage.transactionSync(() => {
+        for (const stmt of statements) {
+          this.ctx.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
         }
-      }
-      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: statements.length,
+        batches: 1,
+        errors: [],
+        edgesDeleted: edgeDocIds.length,
+        nodeDeleted: nodeExists
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return {
+        deleted: 0,
+        batches: 0,
+        errors: [{ batchIndex: 0, error, operationCount: statements.length }],
+        edgesDeleted: 0,
+        nodeDeleted: false
+      };
     }
-    return { deleted, batches, errors };
   }
-  // --- Cross-scope (collection group) ---
-  async findEdgesGlobal(params, collectionName) {
+  async _fgBulkRemoveEdges(params, _options) {
     const plan = buildEdgeQueryPlan(params);
+    let docIds;
     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 existsStmt = compileDOSelectByDocId(this.table, plan.docId);
+      const rows = this.execAll(existsStmt);
+      docIds = rows.length > 0 ? [plan.docId] : [];
+    } else {
+      const selectStmt = compileDOSelect(this.table, plan.filters, plan.options);
+      const rows = this.execAll(selectStmt);
+      docIds = rows.map(
+        (row) => computeEdgeDocId(row.a_uid, row.axb_type, row.b_uid)
       );
     }
-    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);
-}
-
-// src/do-sqlite.ts
-var DOSqliteExecutor = class {
-  constructor(storage) {
-    this.storage = storage;
-  }
-  async all(sql, params) {
-    return this.storage.sql.exec(sql, ...params).toArray();
-  }
-  async run(sql, params) {
-    this.storage.sql.exec(sql, ...params).toArray();
-  }
-  async batch(statements) {
-    if (statements.length === 0) return;
-    this.storage.transactionSync(() => {
-      for (const s of statements) {
-        this.storage.sql.exec(s.sql, ...s.params).toArray();
-      }
-    });
-  }
-  async transaction(fn) {
-    this.storage.sql.exec("BEGIN IMMEDIATE").toArray();
+    if (docIds.length === 0) {
+      return { deleted: 0, batches: 0, errors: [] };
+    }
+    const deleteStmts = docIds.map((id) => compileDODelete(this.table, id));
     try {
-      const txExec = {
-        all: async (sql, params) => this.storage.sql.exec(sql, ...params).toArray(),
-        run: async (sql, params) => {
-          this.storage.sql.exec(sql, ...params).toArray();
+      this.ctx.storage.transactionSync(() => {
+        for (const stmt of deleteStmts) {
+          this.ctx.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
         }
-      };
-      const result = await fn(txExec);
-      this.storage.sql.exec("COMMIT").toArray();
-      return result;
+      });
+      return { deleted: deleteStmts.length, batches: 1, errors: [] };
     } catch (err) {
-      this.storage.sql.exec("ROLLBACK").toArray();
-      throw err;
+      const error = err instanceof Error ? err : new Error(String(err));
+      return {
+        deleted: 0,
+        batches: 0,
+        errors: [{ batchIndex: 0, error, operationCount: deleteStmts.length }]
+      };
     }
   }
-};
-function ensureSchema(storage, table) {
-  const statements = buildSchemaStatements(table);
-  for (const sql of statements) {
-    storage.sql.exec(sql).toArray();
-  }
-}
-function createDOSqliteGraphClient(storage, options = {}) {
-  const table = options.table ?? "firegraph";
-  validateTableName(table);
-  if (options.autoMigrate !== false) {
-    ensureSchema(storage, table);
-  }
-  const executor = new DOSqliteExecutor(storage);
-  const backend = createSqliteBackend(executor, table);
-  const { table: _t, autoMigrate: _m, ...clientOptions } = options;
-  void _t;
-  void _m;
-  let metaBackend;
-  if (clientOptions.registryMode && typeof clientOptions.registryMode === "object" && clientOptions.registryMode.collection && clientOptions.registryMode.collection !== table) {
-    const metaTable = clientOptions.registryMode.collection;
-    validateTableName(metaTable);
-    if (options.autoMigrate !== false) {
-      ensureSchema(storage, metaTable);
+  // ---------------------------------------------------------------------------
+  // RPC: admin
+  // ---------------------------------------------------------------------------
+  /**
+   * Wipe every row. Called by the client when tearing down a subgraph DO as
+   * part of cascade — the DO itself can't be destroyed (DO IDs persist
+   * forever), but its storage can be emptied.
+   */
+  async _fgDestroy() {
+    const stmt = compileDODeleteAll(this.table);
+    this.execRun(stmt);
+  }
+  // ---------------------------------------------------------------------------
+  // Internals
+  // ---------------------------------------------------------------------------
+  runSchema() {
+    const statements = buildDOSchemaStatements(this.table, {
+      coreIndexes: this.coreIndexes,
+      registry: this.registry
+    });
+    for (const sql of statements) {
+      this.ctx.storage.sql.exec(sql).toArray();
     }
-    metaBackend = createSqliteBackend(executor, metaTable);
   }
-  return createGraphClientFromBackend(backend, clientOptions, metaBackend);
-}
+  execAll(stmt) {
+    return this.ctx.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
+  }
+  execRun(stmt) {
+    this.ctx.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDOSqliteGraphClient
+  DORPCBackend,
+  FiregraphDO,
+  buildDOSchemaStatements,
+  createDOClient,
+  createSiblingClient
 });
-//# sourceMappingURL=do-sqlite.cjs.map
+//# sourceMappingURL=index.cjs.map