@typicalday/firegraph 0.7.1 → 0.9.0

package/dist/index.js

@@ -1,838 +1,357 @@
+import {
+  SERIALIZATION_TAG,
+  deserializeFirestoreTypes,
+  isTaggedValue,
+  serializeFirestoreTypes
+} from "./chunk-5753Y42M.js";
+import {
+  appendStorageScope,
+  isAncestorScopeUid,
+  parseStorageScope,
+  resolveAncestorScope
+} from "./chunk-TYYPRVIE.js";
+import {
+  BOOTSTRAP_ENTRIES,
+  DEFAULT_QUERY_LIMIT,
+  EDGE_TYPE_SCHEMA,
+  GraphClientImpl,
+  META_EDGE_TYPE,
+  META_NODE_TYPE,
+  NODE_RELATION,
+  NODE_TYPE_SCHEMA,
+  analyzeQuerySafety,
+  applyMigrationChain,
+  buildEdgeQueryPlan,
+  buildNodeQueryPlan,
+  compileMigrationFn,
+  compileMigrations,
+  compileSchema,
+  computeEdgeDocId,
+  computeNodeDocId,
+  createBootstrapRegistry,
+  createGraphClientFromBackend,
+  createMergedRegistry,
+  createRegistry,
+  createRegistryFromGraph,
+  defaultExecutor,
+  destroySandboxWorker,
+  generateDeterministicUid,
+  jsonSchemaToFieldMeta,
+  matchScope,
+  matchScopeAny,
+  migrateRecord,
+  migrateRecords,
+  precompileSource,
+  validateMigrationChain
+} from "./chunk-EVUM6ORB.js";
+import {
+  CrossBackendTransactionError,
+  DynamicRegistryError,
+  EdgeNotFoundError,
+  FiregraphError,
+  InvalidQueryError,
+  MigrationError,
+  NodeNotFoundError,
+  QuerySafetyError,
+  RegistryScopeError,
+  RegistryViolationError,
+  TraversalError,
+  ValidationError
+} from "./chunk-GLOVWKQH.js";
 import {
   generateTypes
 } from "./chunk-YLGXLEUE.js";
 import {
   QueryClient,
   QueryClientError
-} from "./chunk-KFA7G37W.js";
-
-// src/client.ts
-import { FieldValue as FieldValue5 } from "@google-cloud/firestore";
-
-// src/docid.ts
-import { createHash } from "crypto";
+} from "./chunk-SU4FNLC3.js";
 
-// 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;
+// src/config.ts
+function defineConfig(config) {
+  return config;
 }
-function computeEdgeDocId(aUid, axbType, bUid) {
-  const composite = `${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
-  const hash = createHash("sha256").update(composite).digest("hex");
-  const shard = hash[0];
-  return `${shard}${SHARD_SEPARATOR}${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
+function resolveView(resolverConfig, availableViewNames, context) {
+  if (!resolverConfig) return "json";
+  const available = new Set(availableViewNames);
+  if (context) {
+    const contextDefault = resolverConfig[context];
+    if (contextDefault && available.has(contextDefault)) {
+      return contextDefault;
+    }
+  }
+  if (resolverConfig.default && available.has(resolverConfig.default)) {
+    return resolverConfig.default;
+  }
+  return "json";
 }
 
-// src/record.ts
-import { FieldValue } from "@google-cloud/firestore";
-function buildNodeRecord(aType, uid, data) {
-  const now = FieldValue.serverTimestamp();
-  return {
-    aType,
-    aUid: uid,
-    axbType: NODE_RELATION,
-    bType: aType,
-    bUid: uid,
-    data,
-    createdAt: now,
-    updatedAt: now
-  };
+// src/cross-graph.ts
+function resolveAncestorCollection(collectionPath, uid) {
+  const segments = collectionPath.split("/");
+  for (let i = 1; i < segments.length; i += 2) {
+    if (segments[i] === uid) {
+      return segments.slice(0, i).join("/");
+    }
+  }
+  return null;
 }
-function buildEdgeRecord(aType, aUid, axbType, bType, bUid, data) {
-  const now = FieldValue.serverTimestamp();
-  return {
-    aType,
-    aUid,
-    axbType,
-    bType,
-    bUid,
-    data,
-    createdAt: now,
-    updatedAt: now
-  };
+function isAncestorUid(collectionPath, uid) {
+  return resolveAncestorCollection(collectionPath, uid) !== null;
 }
 
-// src/errors.ts
-var FiregraphError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "FiregraphError";
-  }
-};
-var NodeNotFoundError = class extends FiregraphError {
-  constructor(uid) {
-    super(`Node not found: ${uid}`, "NODE_NOT_FOUND");
-    this.name = "NodeNotFoundError";
-  }
-};
-var EdgeNotFoundError = class extends FiregraphError {
-  constructor(aUid, axbType, bUid) {
-    super(`Edge not found: ${aUid} -[${axbType}]-> ${bUid}`, "EDGE_NOT_FOUND");
-    this.name = "EdgeNotFoundError";
-  }
-};
-var ValidationError = class extends FiregraphError {
-  constructor(message, details) {
-    super(message, "VALIDATION_ERROR");
-    this.details = details;
-    this.name = "ValidationError";
-  }
-};
-var RegistryViolationError = class extends FiregraphError {
-  constructor(aType, axbType, bType) {
-    super(
-      `Unregistered triple: (${aType}) -[${axbType}]-> (${bType})`,
-      "REGISTRY_VIOLATION"
-    );
-    this.name = "RegistryViolationError";
-  }
-};
-var InvalidQueryError = class extends FiregraphError {
-  constructor(message) {
-    super(message, "INVALID_QUERY");
-    this.name = "InvalidQueryError";
-  }
-};
-var TraversalError = class extends FiregraphError {
+// src/discover.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { createRequire } from "module";
+import { join, resolve } from "path";
+var DiscoveryError = class extends FiregraphError {
   constructor(message) {
-    super(message, "TRAVERSAL_ERROR");
-    this.name = "TraversalError";
+    super(message, "DISCOVERY_ERROR");
+    this.name = "DiscoveryError";
   }
 };
-var DynamicRegistryError = class extends FiregraphError {
-  constructor(message) {
-    super(message, "DYNAMIC_REGISTRY_ERROR");
-    this.name = "DynamicRegistryError";
+function readJson(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof SyntaxError ? `Invalid JSON in ${filePath}: ${err.message}` : `Cannot read ${filePath}: ${err.message}`;
+    throw new DiscoveryError(msg);
   }
-};
-var QuerySafetyError = class extends FiregraphError {
-  constructor(message) {
-    super(message, "QUERY_SAFETY");
-    this.name = "QuerySafetyError";
+}
+function readJsonIfExists(filePath) {
+  if (!existsSync(filePath)) return void 0;
+  return readJson(filePath);
+}
+var SCHEMA_SCRIPT_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
+function loadSchema(dir, entityLabel) {
+  for (const ext of SCHEMA_SCRIPT_EXTENSIONS) {
+    const candidate = join(dir, `schema${ext}`);
+    if (existsSync(candidate)) {
+      return loadSchemaModule(candidate, entityLabel);
+    }
   }
-};
-var RegistryScopeError = class extends FiregraphError {
-  constructor(aType, axbType, bType, scopePath, allowedIn) {
-    super(
-      `Type (${aType}) -[${axbType}]-> (${bType}) is not allowed at scope "${scopePath || "root"}". Allowed in: [${allowedIn.join(", ")}]`,
-      "REGISTRY_SCOPE"
-    );
-    this.name = "RegistryScopeError";
+  const jsonPath = join(dir, "schema.json");
+  if (existsSync(jsonPath)) {
+    return readJson(jsonPath);
   }
-};
-var MigrationError = class extends FiregraphError {
-  constructor(message) {
-    super(message, "MIGRATION_ERROR");
-    this.name = "MigrationError";
+  throw new DiscoveryError(
+    `Missing schema for ${entityLabel} in ${dir}. Provide a schema.ts (or .js/.mts/.mjs) or schema.json file.`
+  );
+}
+var _jiti;
+function getJiti() {
+  if (!_jiti) {
+    const base = typeof __filename !== "undefined" ? __filename : import.meta.url;
+    const esmRequire = createRequire(base);
+    const { createJiti } = esmRequire("jiti");
+    _jiti = createJiti(base, { interopDefault: true });
   }
-};
-
-// src/query.ts
-function buildEdgeQueryPlan(params) {
-  const { aType, aUid, axbType, bType, bUid, limit, orderBy } = params;
-  if (aUid && axbType && bUid && !params.where?.length) {
-    return { strategy: "get", docId: computeEdgeDocId(aUid, axbType, bUid) };
-  }
-  const filters = [];
-  if (aType) filters.push({ field: "aType", op: "==", value: aType });
-  if (aUid) filters.push({ field: "aUid", op: "==", value: aUid });
-  if (axbType) filters.push({ field: "axbType", op: "==", value: axbType });
-  if (bType) filters.push({ field: "bType", op: "==", value: bType });
-  if (bUid) filters.push({ field: "bUid", op: "==", value: bUid });
-  if (params.where) {
-    for (const clause of params.where) {
-      const field = BUILTIN_FIELDS.has(clause.field) ? clause.field : clause.field.startsWith("data.") ? clause.field : `data.${clause.field}`;
-      filters.push({ field, op: clause.op, value: clause.value });
+  return _jiti;
+}
+function loadSchemaModule(filePath, entityLabel) {
+  try {
+    const jiti = getJiti();
+    const mod = jiti(filePath);
+    const schema = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+    if (!schema || typeof schema !== "object") {
+      throw new DiscoveryError(
+        `Schema file ${filePath} for ${entityLabel} must default-export a JSON Schema object.`
+      );
     }
+    return schema;
+  } catch (err) {
+    if (err instanceof DiscoveryError) throw err;
+    throw new DiscoveryError(
+      `Failed to load schema module ${filePath} for ${entityLabel}: ${err.message}`
+    );
   }
-  if (filters.length === 0) {
-    throw new InvalidQueryError("findEdges requires at least one filter parameter");
+}
+var VIEW_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
+function findViewsFile(dir) {
+  for (const ext of VIEW_EXTENSIONS) {
+    const candidate = join(dir, `views${ext}`);
+    if (existsSync(candidate)) return candidate;
   }
-  const effectiveLimit = limit === void 0 ? DEFAULT_QUERY_LIMIT : limit || void 0;
-  return { strategy: "query", filters, options: { limit: effectiveLimit, orderBy } };
+  return void 0;
 }
-function buildNodeQueryPlan(params) {
-  const { aType, limit, orderBy } = params;
-  const filters = [
-    { field: "aType", op: "==", value: aType },
-    { field: "axbType", op: "==", value: NODE_RELATION }
-  ];
-  if (params.where) {
-    for (const clause of params.where) {
-      const field = BUILTIN_FIELDS.has(clause.field) ? clause.field : clause.field.startsWith("data.") ? clause.field : `data.${clause.field}`;
-      filters.push({ field, op: clause.op, value: clause.value });
-    }
+var MIGRATION_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
+function findMigrationsFile(dir) {
+  for (const ext of MIGRATION_EXTENSIONS) {
+    const candidate = join(dir, `migrations${ext}`);
+    if (existsSync(candidate)) return candidate;
   }
-  const effectiveLimit = limit === void 0 ? DEFAULT_QUERY_LIMIT : limit || void 0;
-  return { strategy: "query", filters, options: { limit: effectiveLimit, orderBy } };
+  return void 0;
 }
-
-// src/internal/firestore-adapter.ts
-function createFirestoreAdapter(db, collectionPath) {
-  const collectionRef = db.collection(collectionPath);
-  return {
-    collectionPath,
-    async getDoc(docId) {
-      const snap = await collectionRef.doc(docId).get();
-      if (!snap.exists) return null;
-      return snap.data();
-    },
-    async setDoc(docId, data) {
-      await collectionRef.doc(docId).set(data);
-    },
-    async updateDoc(docId, data) {
-      await collectionRef.doc(docId).update(data);
-    },
-    async deleteDoc(docId) {
-      await collectionRef.doc(docId).delete();
-    },
-    async query(filters, options) {
-      let q = collectionRef;
-      for (const f of filters) {
-        q = q.where(f.field, f.op, f.value);
-      }
-      if (options?.orderBy) {
-        q = q.orderBy(options.orderBy.field, options.orderBy.direction ?? "asc");
-      }
-      if (options?.limit !== void 0) {
-        q = q.limit(options.limit);
-      }
-      const snap = await q.get();
-      return snap.docs.map((doc) => doc.data());
+function loadMigrations(filePath, entityLabel) {
+  try {
+    const jiti = getJiti();
+    const mod = jiti(filePath);
+    const migrations = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+    if (!Array.isArray(migrations)) {
+      throw new DiscoveryError(
+        `Migrations file ${filePath} for ${entityLabel} must default-export an array of MigrationStep.`
+      );
     }
-  };
+    return migrations;
+  } catch (err) {
+    if (err instanceof DiscoveryError) throw err;
+    throw new DiscoveryError(
+      `Failed to load migrations ${filePath} for ${entityLabel}: ${err.message}`
+    );
+  }
 }
-function createTransactionAdapter(db, collectionPath, tx) {
-  const collectionRef = db.collection(collectionPath);
+function loadNodeEntity(dir, name) {
+  const schema = loadSchema(dir, `node type "${name}"`);
+  const meta = readJsonIfExists(join(dir, "meta.json"));
+  const sampleData = readJsonIfExists(join(dir, "sample.json"));
+  const viewsPath = findViewsFile(dir);
+  const migrationsPath = findMigrationsFile(dir);
+  const migrations = migrationsPath ? loadMigrations(migrationsPath, `node type "${name}"`) : void 0;
   return {
-    async getDoc(docId) {
-      const snap = await tx.get(collectionRef.doc(docId));
-      if (!snap.exists) return null;
-      return snap.data();
-    },
-    setDoc(docId, data) {
-      tx.set(collectionRef.doc(docId), data);
-    },
-    updateDoc(docId, data) {
-      tx.update(collectionRef.doc(docId), data);
-    },
-    deleteDoc(docId) {
-      tx.delete(collectionRef.doc(docId));
-    },
-    async query(filters, options) {
-      let q = collectionRef;
-      for (const f of filters) {
-        q = q.where(f.field, f.op, f.value);
-      }
-      if (options?.orderBy) {
-        q = q.orderBy(options.orderBy.field, options.orderBy.direction ?? "asc");
-      }
-      if (options?.limit !== void 0) {
-        q = q.limit(options.limit);
-      }
-      const snap = await tx.get(q);
-      return snap.docs.map((doc) => doc.data());
-    }
-  };
-}
-function createBatchAdapter(db, collectionPath) {
-  const collectionRef = db.collection(collectionPath);
-  const batch = db.batch();
-  return {
-    setDoc(docId, data) {
-      batch.set(collectionRef.doc(docId), data);
-    },
-    updateDoc(docId, data) {
-      batch.update(collectionRef.doc(docId), data);
-    },
-    deleteDoc(docId) {
-      batch.delete(collectionRef.doc(docId));
-    },
-    async commit() {
-      await batch.commit();
-    }
+    kind: "node",
+    name,
+    schema,
+    description: meta?.description,
+    titleField: meta?.titleField,
+    subtitleField: meta?.subtitleField,
+    viewDefaults: meta?.viewDefaults,
+    viewsPath,
+    sampleData,
+    allowedIn: meta?.allowedIn,
+    migrations,
+    migrationWriteBack: meta?.migrationWriteBack
   };
 }
-
-// src/internal/pipeline-adapter.ts
-var _Pipelines = null;
-async function getPipelines() {
-  if (!_Pipelines) {
-    const mod = await import("@google-cloud/firestore");
-    _Pipelines = mod.Pipelines;
+function loadEdgeEntity(dir, name) {
+  const schema = loadSchema(dir, `edge type "${name}"`);
+  const edgePath = join(dir, "edge.json");
+  if (!existsSync(edgePath)) {
+    throw new DiscoveryError(
+      `Missing edge.json for edge type "${name}" in ${dir}. Edge entities must declare topology (from/to node types).`
+    );
   }
-  return _Pipelines;
-}
-function buildFilterExpression(P, filter) {
-  const { field: fieldName, op, value } = filter;
-  switch (op) {
-    case "==":
-      return P.equal(fieldName, value);
-    case "!=":
-      return P.notEqual(fieldName, value);
-    case "<":
-      return P.lessThan(fieldName, value);
-    case "<=":
-      return P.lessThanOrEqual(fieldName, value);
-    case ">":
-      return P.greaterThan(fieldName, value);
-    case ">=":
-      return P.greaterThanOrEqual(fieldName, value);
-    case "in":
-      return P.equalAny(fieldName, value);
-    case "not-in":
-      return P.notEqualAny(fieldName, value);
-    case "array-contains":
-      return P.arrayContains(fieldName, value);
-    case "array-contains-any":
-      return P.arrayContainsAny(fieldName, value);
-    default:
-      throw new Error(`Unsupported filter op for pipeline mode: ${op}`);
+  const topology = readJson(edgePath);
+  if (!topology.from) {
+    throw new DiscoveryError(`edge.json for "${name}" is missing required "from" field`);
   }
-}
-function createPipelineQueryAdapter(db, collectionPath) {
+  if (!topology.to) {
+    throw new DiscoveryError(`edge.json for "${name}" is missing required "to" field`);
+  }
+  const meta = readJsonIfExists(join(dir, "meta.json"));
+  const sampleData = readJsonIfExists(join(dir, "sample.json"));
+  const viewsPath = findViewsFile(dir);
+  const migrationsPath = findMigrationsFile(dir);
+  const migrations = migrationsPath ? loadMigrations(migrationsPath, `edge type "${name}"`) : void 0;
   return {
-    async query(filters, options) {
-      const P = await getPipelines();
-      let pipeline = db.pipeline().collection(collectionPath);
-      if (filters.length === 1) {
-        pipeline = pipeline.where(buildFilterExpression(P, filters[0]));
-      } else if (filters.length > 1) {
-        const [first, second, ...rest] = filters.map((f) => buildFilterExpression(P, f));
-        pipeline = pipeline.where(P.and(first, second, ...rest));
-      }
-      if (options?.orderBy) {
-        const f = P.field(options.orderBy.field);
-        const ordering = options.orderBy.direction === "desc" ? f.descending() : f.ascending();
-        pipeline = pipeline.sort(ordering);
-      }
-      if (options?.limit !== void 0) {
-        pipeline = pipeline.limit(options.limit);
-      }
-      const snap = await pipeline.execute();
-      return snap.results.map((r) => r.data());
-    }
+    kind: "edge",
+    name,
+    schema,
+    topology,
+    description: meta?.description,
+    titleField: meta?.titleField,
+    subtitleField: meta?.subtitleField,
+    viewDefaults: meta?.viewDefaults,
+    viewsPath,
+    sampleData,
+    allowedIn: meta?.allowedIn,
+    targetGraph: topology.targetGraph ?? meta?.targetGraph,
+    migrations,
+    migrationWriteBack: meta?.migrationWriteBack
   };
 }
-
-// src/transaction.ts
-import { FieldValue as FieldValue3 } from "@google-cloud/firestore";
-
-// src/query-safety.ts
-var SAFE_INDEX_PATTERNS = [
-  /* @__PURE__ */ new Set(["aUid", "axbType"]),
-  /* @__PURE__ */ new Set(["axbType", "bUid"]),
-  /* @__PURE__ */ new Set(["aType", "axbType"]),
-  /* @__PURE__ */ new Set(["axbType", "bType"])
-];
-function analyzeQuerySafety(filters) {
-  const builtinFieldsPresent = /* @__PURE__ */ new Set();
-  let hasDataFilters = false;
-  for (const f of filters) {
-    if (BUILTIN_FIELDS.has(f.field)) {
-      builtinFieldsPresent.add(f.field);
-    } else {
-      hasDataFilters = true;
-    }
+function getSubdirectories(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+}
+function discoverEntities(entitiesDir) {
+  const absDir = resolve(entitiesDir);
+  if (!existsSync(absDir) || !statSync(absDir).isDirectory()) {
+    throw new DiscoveryError(`Entities directory not found: ${entitiesDir}`);
   }
-  for (const pattern of SAFE_INDEX_PATTERNS) {
-    let matched = true;
-    for (const field of pattern) {
-      if (!builtinFieldsPresent.has(field)) {
-        matched = false;
-        break;
-      }
-    }
-    if (matched) {
-      return { safe: true };
-    }
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const warnings = [];
+  const nodesDir = join(absDir, "nodes");
+  for (const name of getSubdirectories(nodesDir)) {
+    nodes.set(name, loadNodeEntity(join(nodesDir, name), name));
   }
-  const presentFields = [...builtinFieldsPresent];
-  if (presentFields.length === 0 && hasDataFilters) {
-    return {
-      safe: false,
-      reason: "Query filters only use data.* fields with no builtin field constraints. This requires a full collection scan. Add aType, aUid, axbType, bType, or bUid filters, or set allowCollectionScan: true."
-    };
+  const edgesDir = join(absDir, "edges");
+  for (const name of getSubdirectories(edgesDir)) {
+    edges.set(name, loadEdgeEntity(join(edgesDir, name), name));
   }
-  if (hasDataFilters) {
-    return {
-      safe: false,
-      reason: `Query filters on [${presentFields.join(", ")}] do not match any indexed pattern. data.* filters without an indexed base require a full collection scan. Safe patterns: (aUid + axbType), (axbType + bUid), (aType + axbType), (axbType + bType). Set allowCollectionScan: true to override.`
-    };
+  const nodeNames = new Set(nodes.keys());
+  for (const [axbType, entity] of edges) {
+    const topology = entity.topology;
+    const fromTypes = Array.isArray(topology.from) ? topology.from : [topology.from];
+    const toTypes = Array.isArray(topology.to) ? topology.to : [topology.to];
+    for (const ref of [...fromTypes, ...toTypes]) {
+      if (!nodeNames.has(ref)) {
+        warnings.push({
+          code: "DANGLING_TOPOLOGY_REF",
+          message: `Edge "${axbType}" references node type "${ref}" which was not found in the nodes directory`
+        });
+      }
+    }
   }
   return {
-    safe: false,
-    reason: `Query filters on [${presentFields.join(", ")}] do not match any indexed pattern. This may cause a full collection scan on Firestore Enterprise. Safe patterns: (aUid + axbType), (axbType + bUid), (aType + axbType), (axbType + bType). Set allowCollectionScan: true to override.`
+    result: { nodes, edges },
+    warnings
   };
 }
 
-// src/serialization.ts
-import { Timestamp, GeoPoint, FieldValue as FieldValue2 } from "@google-cloud/firestore";
-var SERIALIZATION_TAG = "__firegraph_ser__";
-var KNOWN_TYPES = /* @__PURE__ */ new Set(["Timestamp", "GeoPoint", "VectorValue", "DocumentReference"]);
-var _docRefWarned = false;
-function isTaggedValue(value) {
-  if (value === null || typeof value !== "object") return false;
-  const tag = value[SERIALIZATION_TAG];
-  return typeof tag === "string" && KNOWN_TYPES.has(tag);
-}
-function isTimestamp(value) {
-  return value instanceof Timestamp;
-}
-function isGeoPoint(value) {
-  return value instanceof GeoPoint;
-}
-function isDocumentReference(value) {
-  if (value === null || typeof value !== "object") return false;
-  const v = value;
-  return typeof v.path === "string" && v.firestore !== void 0 && typeof v.id === "string" && v.constructor?.name === "DocumentReference";
-}
-function isVectorValue(value) {
-  if (value === null || typeof value !== "object") return false;
-  const v = value;
-  return v.constructor?.name === "VectorValue" && Array.isArray(v._values);
-}
-function serializeFirestoreTypes(data) {
-  return serializeValue(data);
+// src/internal/firestore-backend.ts
+import { FieldValue } from "@google-cloud/firestore";
+
+// src/bulk.ts
+var MAX_BATCH_SIZE = 500;
+var DEFAULT_MAX_RETRIES = 3;
+var BASE_DELAY_MS = 200;
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function serializeValue(value) {
-  if (value === null || value === void 0) return value;
-  if (typeof value !== "object") return value;
-  if (isTimestamp(value)) {
-    return { [SERIALIZATION_TAG]: "Timestamp", seconds: value.seconds, nanoseconds: value.nanoseconds };
-  }
-  if (isGeoPoint(value)) {
-    return { [SERIALIZATION_TAG]: "GeoPoint", latitude: value.latitude, longitude: value.longitude };
-  }
-  if (isDocumentReference(value)) {
-    return { [SERIALIZATION_TAG]: "DocumentReference", path: value.path };
-  }
-  if (isVectorValue(value)) {
-    const v = value;
-    const values = typeof v.toArray === "function" ? v.toArray() : v._values;
-    return { [SERIALIZATION_TAG]: "VectorValue", values: [...values] };
-  }
-  if (Array.isArray(value)) {
-    return value.map(serializeValue);
-  }
-  const result = {};
-  for (const key of Object.keys(value)) {
-    result[key] = serializeValue(value[key]);
+function chunk(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
   }
-  return result;
-}
-function deserializeFirestoreTypes(data, db) {
-  return deserializeValue(data, db);
+  return chunks;
 }
-function deserializeValue(value, db) {
-  if (value === null || value === void 0) return value;
-  if (typeof value !== "object") return value;
-  if (isTimestamp(value) || isGeoPoint(value) || isDocumentReference(value) || isVectorValue(value)) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => deserializeValue(v, db));
-  }
-  const obj = value;
-  if (isTaggedValue(obj)) {
-    const tag = obj[SERIALIZATION_TAG];
-    switch (tag) {
-      case "Timestamp":
-        if (typeof obj.seconds !== "number" || typeof obj.nanoseconds !== "number") return obj;
-        return new Timestamp(obj.seconds, obj.nanoseconds);
-      case "GeoPoint":
-        if (typeof obj.latitude !== "number" || typeof obj.longitude !== "number") return obj;
-        return new GeoPoint(obj.latitude, obj.longitude);
-      case "VectorValue":
-        if (!Array.isArray(obj.values)) return obj;
-        return FieldValue2.vector(obj.values);
-      case "DocumentReference":
-        if (typeof obj.path !== "string") return obj;
-        if (db) {
-          return db.doc(obj.path);
-        }
-        if (!_docRefWarned) {
-          _docRefWarned = true;
-          console.warn(
-            "[firegraph] DocumentReference encountered during migration deserialization but no Firestore instance available. The reference will remain as a tagged object with its path. Enable write-back for full reconstruction."
-          );
-        }
-        return obj;
-      default:
-        return obj;
-    }
-  }
-  const result = {};
-  for (const key of Object.keys(obj)) {
-    result[key] = deserializeValue(obj[key], db);
+async function bulkDeleteDocIds(db, collectionPath, docIds, options) {
+  if (docIds.length === 0) {
+    return { deleted: 0, batches: 0, errors: [] };
   }
-  return result;
-}
-
-// 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) {
+  const batchSize = Math.min(options?.batchSize ?? MAX_BATCH_SIZE, MAX_BATCH_SIZE);
+  const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const onProgress = options?.onProgress;
+  const chunks = chunk(docIds, batchSize);
+  const errors = [];
+  let deleted = 0;
+  let completedBatches = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const ids = chunks[i];
+    let committed = false;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
-        result = await step.up(result);
+        const batch = db.batch();
+        const collectionRef = db.collection(collectionPath);
+        for (const id of ids) {
+          batch.delete(collectionRef.doc(id));
+        }
+        await batch.commit();
+        committed = true;
+        deleted += ids.length;
+        break;
       } 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/transaction.ts
-var GraphTransactionImpl = class {
-  constructor(adapter, registry, scanProtection = "error", scopePath = "", globalWriteBack = "off", db) {
-    this.adapter = adapter;
-    this.registry = registry;
-    this.scanProtection = scanProtection;
-    this.scopePath = scopePath;
-    this.globalWriteBack = globalWriteBack;
-    this.db = db;
-  }
-  async getNode(uid) {
-    const docId = computeNodeDocId(uid);
-    const record = await this.adapter.getDoc(docId);
-    if (!record || !this.registry) return record;
-    const result = await migrateRecord(record, this.registry, this.globalWriteBack);
-    if (result.migrated && result.writeBack !== "off") {
-      const update = {
-        data: deserializeFirestoreTypes(result.record.data, this.db),
-        updatedAt: FieldValue3.serverTimestamp()
-      };
-      if (result.record.v !== void 0) {
-        update.v = result.record.v;
-      }
-      this.adapter.updateDoc(docId, update);
-    }
-    return result.record;
-  }
-  async getEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = await this.adapter.getDoc(docId);
-    if (!record || !this.registry) return record;
-    const result = await migrateRecord(record, this.registry, this.globalWriteBack);
-    if (result.migrated && result.writeBack !== "off") {
-      const update = {
-        data: deserializeFirestoreTypes(result.record.data, this.db),
-        updatedAt: FieldValue3.serverTimestamp()
-      };
-      if (result.record.v !== void 0) {
-        update.v = result.record.v;
-      }
-      this.adapter.updateDoc(docId, update);
-    }
-    return result.record;
-  }
-  async edgeExists(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = await this.adapter.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.adapter.getDoc(plan.docId);
-      records = record ? [record] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.adapter.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.adapter.getDoc(plan.docId);
-      records = record ? [record] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.adapter.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);
-        const update = {
-          data: deserializeFirestoreTypes(result.record.data, this.db),
-          updatedAt: FieldValue3.serverTimestamp()
-        };
-        if (result.record.v !== void 0) {
-          update.v = result.record.v;
-        }
-        this.adapter.updateDoc(docId, update);
-      }
-    }
-    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 = buildNodeRecord(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.adapter.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 = buildEdgeRecord(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.adapter.setDoc(docId, record);
-  }
-  async updateNode(uid, data) {
-    const docId = computeNodeDocId(uid);
-    const update = {
-      updatedAt: FieldValue3.serverTimestamp()
-    };
-    for (const [k, v] of Object.entries(data)) {
-      update[`data.${k}`] = v;
-    }
-    this.adapter.updateDoc(docId, update);
-  }
-  async removeNode(uid) {
-    const docId = computeNodeDocId(uid);
-    this.adapter.deleteDoc(docId);
-  }
-  async removeEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    this.adapter.deleteDoc(docId);
-  }
-};
-
-// src/batch.ts
-import { FieldValue as FieldValue4 } from "@google-cloud/firestore";
-var GraphBatchImpl = class {
-  constructor(adapter, registry, scopePath = "") {
-    this.adapter = adapter;
-    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 = buildNodeRecord(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.adapter.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 = buildEdgeRecord(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.adapter.setDoc(docId, record);
-  }
-  async updateNode(uid, data) {
-    const docId = computeNodeDocId(uid);
-    const update = {
-      updatedAt: FieldValue4.serverTimestamp()
-    };
-    for (const [k, v] of Object.entries(data)) {
-      update[`data.${k}`] = v;
-    }
-    this.adapter.updateDoc(docId, update);
-  }
-  async removeNode(uid) {
-    const docId = computeNodeDocId(uid);
-    this.adapter.deleteDoc(docId);
-  }
-  async removeEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    this.adapter.deleteDoc(docId);
-  }
-  async commit() {
-    await this.adapter.commit();
-  }
-};
-
-// src/bulk.ts
-var MAX_BATCH_SIZE = 500;
-var DEFAULT_MAX_RETRIES = 3;
-var BASE_DELAY_MS = 200;
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function chunk(arr, size) {
-  const chunks = [];
-  for (let i = 0; i < arr.length; i += size) {
-    chunks.push(arr.slice(i, i + size));
-  }
-  return chunks;
-}
-async function bulkDeleteDocIds(db, collectionPath, docIds, options) {
-  if (docIds.length === 0) {
-    return { deleted: 0, batches: 0, errors: [] };
-  }
-  const batchSize = Math.min(options?.batchSize ?? MAX_BATCH_SIZE, MAX_BATCH_SIZE);
-  const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
-  const onProgress = options?.onProgress;
-  const chunks = chunk(docIds, batchSize);
-  const errors = [];
-  let deleted = 0;
-  let completedBatches = 0;
-  for (let i = 0; i < chunks.length; i++) {
-    const ids = chunks[i];
-    let committed = false;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const batch = db.batch();
-        const collectionRef = db.collection(collectionPath);
-        for (const id of ids) {
-          batch.delete(collectionRef.doc(id));
-        }
-        await batch.commit();
-        committed = true;
-        deleted += ids.length;
-        break;
-      } catch (err) {
-        if (attempt < maxRetries) {
-          const delay = BASE_DELAY_MS * Math.pow(2, attempt);
-          await sleep(delay);
-        } else {
-          errors.push({
-            batchIndex: i,
-            error: err instanceof Error ? err : new Error(String(err)),
-            operationCount: ids.length
-          });
-        }
+        if (attempt < maxRetries) {
+          const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+          await sleep(delay);
+        } else {
+          errors.push({
+            batchIndex: i,
+            error: err instanceof Error ? err : new Error(String(err)),
+            operationCount: ids.length
+          });
+        }
       }
     }
     if (committed) {
@@ -925,1044 +444,288 @@ async function removeNodeCascade(db, collectionPath, reader, uid, options) {
   };
 }
 
-// src/dynamic-registry.ts
-import { createHash as createHash3 } from "crypto";
-
-// src/json-schema.ts
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-var ajv = new Ajv({ allErrors: true, strict: false });
-addFormats(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/firestore-adapter.ts
+function createFirestoreAdapter(db, collectionPath) {
+  const collectionRef = db.collection(collectionPath);
+  return {
+    collectionPath,
+    async getDoc(docId) {
+      const snap = await collectionRef.doc(docId).get();
+      if (!snap.exists) return null;
+      return snap.data();
+    },
+    async setDoc(docId, data) {
+      await collectionRef.doc(docId).set(data);
+    },
+    async updateDoc(docId, data) {
+      await collectionRef.doc(docId).update(data);
+    },
+    async deleteDoc(docId) {
+      await collectionRef.doc(docId).delete();
+    },
+    async query(filters, options) {
+      let q = collectionRef;
+      for (const f of filters) {
+        q = q.where(f.field, f.op, f.value);
+      }
+      if (options?.orderBy) {
+        q = q.orderBy(options.orderBy.field, options.orderBy.direction ?? "asc");
+      }
+      if (options?.limit !== void 0) {
+        q = q.limit(options.limit);
+      }
+      const snap = await q.get();
+      return snap.docs.map((doc) => doc.data());
     }
   };
 }
-function jsonSchemaToFieldMeta(schema) {
-  if (!schema || schema.type !== "object" || !schema.properties) return [];
-  const requiredSet = new Set(
-    Array.isArray(schema.required) ? schema.required : []
-  );
-  return Object.entries(schema.properties).map(
-    ([name, prop]) => propertyToFieldMeta(name, prop, requiredSet.has(name))
-  );
-}
-function propertyToFieldMeta(name, prop, required) {
-  if (!prop) return { name, type: "unknown", required };
-  if (Array.isArray(prop.enum)) {
-    return {
-      name,
-      type: "enum",
-      required,
-      enumValues: prop.enum,
-      description: prop.description
-    };
-  }
-  if (Array.isArray(prop.oneOf) || Array.isArray(prop.anyOf)) {
-    const variants = prop.oneOf ?? prop.anyOf;
-    const nonNull = variants.filter((v) => v.type !== "null");
-    if (nonNull.length === 1) {
-      return propertyToFieldMeta(name, nonNull[0], false);
-    }
-    return { name, type: "unknown", required, description: prop.description };
-  }
-  const type = prop.type;
-  if (type === "string") {
-    return {
-      name,
-      type: "string",
-      required,
-      minLength: prop.minLength,
-      maxLength: prop.maxLength,
-      pattern: prop.pattern,
-      description: prop.description
-    };
-  }
-  if (type === "number" || type === "integer") {
-    return {
-      name,
-      type: "number",
-      required,
-      min: prop.minimum,
-      max: prop.maximum,
-      isInt: type === "integer" ? true : void 0,
-      description: prop.description
-    };
-  }
-  if (type === "boolean") {
-    return { name, type: "boolean", required, description: prop.description };
-  }
-  if (type === "array") {
-    const itemMeta = prop.items ? propertyToFieldMeta("item", prop.items, true) : void 0;
-    return {
-      name,
-      type: "array",
-      required,
-      itemMeta,
-      description: prop.description
-    };
-  }
-  if (type === "object") {
-    return {
-      name,
-      type: "object",
-      required,
-      fields: jsonSchemaToFieldMeta(prop),
-      description: prop.description
-    };
-  }
-  return { name, type: "unknown", required, description: prop.description };
-}
-
-// 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));
-  }
+function createTransactionAdapter(db, collectionPath, tx) {
+  const collectionRef = db.collection(collectionPath);
   return {
-    lookup(aType, axbType, bType) {
-      return map.get(tripleKey(aType, axbType, bType))?.entry;
+    async getDoc(docId) {
+      const snap = await tx.get(collectionRef.doc(docId));
+      if (!snap.exists) return null;
+      return snap.data();
+    },
+    setDoc(docId, data) {
+      tx.set(collectionRef.doc(docId), data);
+    },
+    updateDoc(docId, data) {
+      tx.update(collectionRef.doc(docId), data);
     },
-    lookupByAxbType(axbType) {
-      return axbIndex.get(axbType) ?? [];
+    deleteDoc(docId) {
+      tx.delete(collectionRef.doc(docId));
     },
-    validate(aType, axbType, bType, data, scopePath) {
-      const rec = map.get(tripleKey(aType, axbType, bType));
-      if (!rec) {
-        throw new RegistryViolationError(aType, axbType, bType);
+    async query(filters, options) {
+      let q = collectionRef;
+      for (const f of filters) {
+        q = q.where(f.field, f.op, f.value);
       }
-      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 (options?.orderBy) {
+        q = q.orderBy(options.orderBy.field, options.orderBy.direction ?? "asc");
       }
-      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
-          );
-        }
+      if (options?.limit !== void 0) {
+        q = q.limit(options.limit);
       }
-    },
-    entries() {
-      return entryList;
+      const snap = await tx.get(q);
+      return snap.docs.map((doc) => doc.data());
     }
   };
 }
-function createMergedRegistry(base, extension) {
-  const baseKeys = new Set(base.entries().map(tripleKeyFor));
+function createBatchAdapter(db, collectionPath) {
+  const collectionRef = db.collection(collectionPath);
+  const batch = db.batch();
   return {
-    lookup(aType, axbType, bType) {
-      return base.lookup(aType, axbType, bType) ?? extension.lookup(aType, axbType, bType);
+    setDoc(docId, data) {
+      batch.set(collectionRef.doc(docId), data);
     },
-    lookupByAxbType(axbType) {
-      const baseResults = base.lookupByAxbType(axbType);
-      const extResults = extension.lookupByAxbType(axbType);
-      if (extResults.length === 0) return baseResults;
-      if (baseResults.length === 0) return extResults;
-      const seen = new Set(baseResults.map(tripleKeyFor));
-      const merged = [...baseResults];
-      for (const entry of extResults) {
-        if (!seen.has(tripleKeyFor(entry))) {
-          merged.push(entry);
-        }
-      }
-      return Object.freeze(merged);
+    updateDoc(docId, data) {
+      batch.update(collectionRef.doc(docId), data);
     },
-    validate(aType, axbType, bType, data, scopePath) {
-      if (baseKeys.has(tripleKey(aType, axbType, bType))) {
-        return base.validate(aType, axbType, bType, data, scopePath);
-      }
-      return extension.validate(aType, axbType, bType, data, scopePath);
+    deleteDoc(docId) {
+      batch.delete(collectionRef.doc(docId));
     },
-    entries() {
-      const extEntries = extension.entries();
-      if (extEntries.length === 0) return base.entries();
-      const merged = [...base.entries()];
-      for (const entry of extEntries) {
-        if (!baseKeys.has(tripleKeyFor(entry))) {
-          merged.push(entry);
-        }
-      }
-      return Object.freeze(merged);
+    async commit() {
+      await batch.commit();
     }
   };
 }
-function discoveryToEntries(discovery) {
-  const entries = [];
-  for (const [name, entity] of discovery.nodes) {
-    entries.push({
-      aType: name,
-      axbType: NODE_RELATION,
-      bType: name,
-      jsonSchema: entity.schema,
-      description: entity.description,
-      titleField: entity.titleField,
-      subtitleField: entity.subtitleField,
-      allowedIn: entity.allowedIn,
-      migrations: entity.migrations,
-      migrationWriteBack: entity.migrationWriteBack
-    });
-  }
-  for (const [axbType, entity] of discovery.edges) {
-    const topology = entity.topology;
-    if (!topology) continue;
-    const fromTypes = Array.isArray(topology.from) ? topology.from : [topology.from];
-    const toTypes = Array.isArray(topology.to) ? topology.to : [topology.to];
-    const resolvedTargetGraph = entity.targetGraph ?? topology.targetGraph;
-    if (resolvedTargetGraph && resolvedTargetGraph.includes("/")) {
-      throw new ValidationError(
-        `Edge "${axbType}" has invalid targetGraph "${resolvedTargetGraph}" \u2014 must be a single segment (no "/")`
-      );
-    }
-    for (const aType of fromTypes) {
-      for (const bType of toTypes) {
-        entries.push({
-          aType,
-          axbType,
-          bType,
-          jsonSchema: entity.schema,
-          description: entity.description,
-          inverseLabel: topology.inverseLabel,
-          titleField: entity.titleField,
-          subtitleField: entity.subtitleField,
-          allowedIn: entity.allowedIn,
-          targetGraph: resolvedTargetGraph,
-          migrations: entity.migrations,
-          migrationWriteBack: entity.migrationWriteBack
-        });
-      }
-    }
-  }
-  return entries;
-}
 
-// src/sandbox.ts
-import { Worker } from "worker_threads";
-import { createHash as createHash2 } from "crypto";
-var _worker = null;
-var _requestId = 0;
-var _pending = /* @__PURE__ */ new Map();
-var WORKER_SOURCE = [
-  `'use strict';`,
-  `var _wt = require('node:worker_threads');`,
-  `var _mod = require('node:module');`,
-  `var _crypto = require('node:crypto');`,
-  `var parentPort = _wt.parentPort;`,
-  `var workerData = _wt.workerData;`,
-  ``,
-  `// Load SES using the parent module's resolution context`,
-  `var esmRequire = _mod.createRequire(workerData.parentUrl);`,
-  `esmRequire('ses');`,
-  ``,
-  `lockdown({`,
-  `  errorTaming: 'unsafe',`,
-  `  consoleTaming: 'unsafe',`,
-  `  evalTaming: 'safe-eval',`,
-  `  overrideTaming: 'moderate',`,
-  `  stackFiltering: 'verbose'`,
-  `});`,
-  ``,
-  `// Defense-in-depth: verify lockdown() actually hardened JSON.`,
-  `if (!Object.isFrozen(JSON)) {`,
-  `  throw new Error('SES lockdown failed: JSON is not frozen');`,
-  `}`,
-  ``,
-  `var cache = new Map();`,
-  ``,
-  `function hashSource(s) {`,
-  `  return _crypto.createHash('sha256').update(s).digest('hex');`,
-  `}`,
-  ``,
-  `function buildWrapper(source) {`,
-  `  return '(function() {' +`,
-  `    '  var fn = (' + source + ');\\n' +`,
-  `    '  if (typeof fn !== "function") return null;\\n' +`,
-  `    '  return function(jsonIn) {\\n' +`,
-  `    '    var data = JSON.parse(jsonIn);\\n' +`,
-  `    '    var result = fn(data);\\n' +`,
-  `    '    if (result !== null && typeof result === "object" && typeof result.then === "function") {\\n' +`,
-  `    '      return result.then(function(r) { return JSON.stringify(r); });\\n' +`,
-  `    '    }\\n' +`,
-  `    '    return JSON.stringify(result);\\n' +`,
-  `    '  };\\n' +`,
-  `    '})()';`,
-  `}`,
-  ``,
-  `function compileSource(source) {`,
-  `  var key = hashSource(source);`,
-  `  var cached = cache.get(key);`,
-  `  if (cached) return cached;`,
-  ``,
-  `  var compartmentFn;`,
-  `  try {`,
-  `    var c = new Compartment({ JSON: JSON });`,
-  `    compartmentFn = c.evaluate(buildWrapper(source));`,
-  `  } catch (err) {`,
-  `    throw new Error('Failed to compile migration source: ' + (err.message || String(err)));`,
-  `  }`,
-  ``,
-  `  if (typeof compartmentFn !== 'function') {`,
-  `    throw new Error('Migration source did not produce a function: ' + source.slice(0, 80));`,
-  `  }`,
-  ``,
-  `  cache.set(key, compartmentFn);`,
-  `  return compartmentFn;`,
-  `}`,
-  ``,
-  `parentPort.on('message', function(msg) {`,
-  `  var id = msg.id;`,
-  `  try {`,
-  `    if (msg.type === 'compile') {`,
-  `      compileSource(msg.source);`,
-  `      parentPort.postMessage({ id: id, type: 'compiled' });`,
-  `      return;`,
-  `    }`,
-  `    if (msg.type === 'execute') {`,
-  `      var fn = compileSource(msg.source);`,
-  `      var raw;`,
-  `      try {`,
-  `        raw = fn(msg.jsonData);`,
-  `      } catch (err) {`,
-  `        parentPort.postMessage({ id: id, type: 'error', message: 'Migration function threw: ' + (err.message || String(err)) });`,
-  `        return;`,
-  `      }`,
-  `      if (raw !== null && typeof raw === 'object' && typeof raw.then === 'function') {`,
-  `        raw.then(`,
-  `          function(jsonResult) {`,
-  `            if (jsonResult === undefined || jsonResult === null) {`,
-  `              parentPort.postMessage({ id: id, type: 'error', message: 'Migration returned a non-JSON-serializable value' });`,
-  `            } else {`,
-  `              parentPort.postMessage({ id: id, type: 'result', jsonResult: jsonResult });`,
-  `            }`,
-  `          },`,
-  `          function(err) {`,
-  `            parentPort.postMessage({ id: id, type: 'error', message: 'Async migration function threw: ' + (err.message || String(err)) });`,
-  `          }`,
-  `        );`,
-  `        return;`,
-  `      }`,
-  `      if (raw === undefined || raw === null) {`,
-  `        parentPort.postMessage({ id: id, type: 'error', message: 'Migration returned a non-JSON-serializable value' });`,
-  `      } else {`,
-  `        parentPort.postMessage({ id: id, type: 'result', jsonResult: raw });`,
-  `      }`,
-  `    }`,
-  `  } catch (err) {`,
-  `    parentPort.postMessage({ id: id, type: 'error', message: err.message || String(err) });`,
-  `  }`,
-  `});`
-].join("\n");
-function ensureWorker() {
-  if (_worker) return _worker;
-  _worker = new Worker(WORKER_SOURCE, {
-    eval: true,
-    workerData: { parentUrl: import.meta.url }
-  });
-  _worker.unref();
-  _worker.on("message", (msg) => {
-    if (msg.id === void 0) return;
-    const pending = _pending.get(msg.id);
-    if (!pending) return;
-    _pending.delete(msg.id);
-    if (msg.type === "error") {
-      pending.reject(new MigrationError(msg.message ?? "Unknown sandbox error"));
-    } else {
-      pending.resolve(msg);
-    }
-  });
-  _worker.on("error", (err) => {
-    for (const [, p] of _pending) {
-      p.reject(new MigrationError(`Sandbox worker error: ${err.message}`));
-    }
-    _pending.clear();
-    _worker = null;
-  });
-  _worker.on("exit", (code) => {
-    if (_pending.size > 0) {
-      for (const [, p] of _pending) {
-        p.reject(new MigrationError(`Sandbox worker exited with code ${code}`));
-      }
-      _pending.clear();
-    }
-    _worker = null;
-  });
-  return _worker;
-}
-function sendToWorker(msg) {
-  const worker = ensureWorker();
-  if (_requestId >= Number.MAX_SAFE_INTEGER) _requestId = 0;
-  const id = ++_requestId;
-  return new Promise((resolve2, reject) => {
-    _pending.set(id, { resolve: resolve2, reject });
-    worker.postMessage({ ...msg, id });
-  });
-}
-var compiledCache = /* @__PURE__ */ new WeakMap();
-function getExecutorCache(executor) {
-  let cache = compiledCache.get(executor);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    compiledCache.set(executor, cache);
-  }
-  return cache;
+// src/internal/pipeline-adapter.ts
+var _Pipelines = null;
+async function getPipelines() {
+  if (!_Pipelines) {
+    const mod = await import("@google-cloud/firestore");
+    _Pipelines = mod.Pipelines;
+  }
+  return _Pipelines;
 }
-function hashSource(source) {
-  return createHash2("sha256").update(source).digest("hex");
+function buildFilterExpression(P, filter) {
+  const { field: fieldName, op, value } = filter;
+  switch (op) {
+    case "==":
+      return P.equal(fieldName, value);
+    case "!=":
+      return P.notEqual(fieldName, value);
+    case "<":
+      return P.lessThan(fieldName, value);
+    case "<=":
+      return P.lessThanOrEqual(fieldName, value);
+    case ">":
+      return P.greaterThan(fieldName, value);
+    case ">=":
+      return P.greaterThanOrEqual(fieldName, value);
+    case "in":
+      return P.equalAny(fieldName, value);
+    case "not-in":
+      return P.notEqualAny(fieldName, value);
+    case "array-contains":
+      return P.arrayContains(fieldName, value);
+    case "array-contains-any":
+      return P.arrayContainsAny(fieldName, value);
+    default:
+      throw new Error(`Unsupported filter op for pipeline mode: ${op}`);
+  }
 }
-function defaultExecutor(source) {
-  ensureWorker();
-  return ((data) => {
-    const jsonData = JSON.stringify(serializeFirestoreTypes(data));
-    return sendToWorker({ type: "execute", source, jsonData }).then(
-      (response) => {
-        if (response.jsonResult === void 0 || response.jsonResult === null) {
-          throw new MigrationError("Migration returned a non-JSON-serializable value");
-        }
-        try {
-          return deserializeFirestoreTypes(JSON.parse(response.jsonResult));
-        } catch {
-          throw new MigrationError("Migration returned a non-JSON-serializable value");
-        }
+function createPipelineQueryAdapter(db, collectionPath) {
+  return {
+    async query(filters, options) {
+      const P = await getPipelines();
+      let pipeline = db.pipeline().collection(collectionPath);
+      if (filters.length === 1) {
+        pipeline = pipeline.where(buildFilterExpression(P, filters[0]));
+      } else if (filters.length > 1) {
+        const [first, second, ...rest] = filters.map((f) => buildFilterExpression(P, f));
+        pipeline = pipeline.where(P.and(first, second, ...rest));
       }
-    );
-  });
+      if (options?.orderBy) {
+        const f = P.field(options.orderBy.field);
+        const ordering = options.orderBy.direction === "desc" ? f.descending() : f.ascending();
+        pipeline = pipeline.sort(ordering);
+      }
+      if (options?.limit !== void 0) {
+        pipeline = pipeline.limit(options.limit);
+      }
+      const snap = await pipeline.execute();
+      return snap.results.map((r) => r.data());
+    }
+  };
 }
-async function precompileSource(source, executor) {
-  if (executor && executor !== defaultExecutor) {
-    try {
-      executor(source);
-    } catch (err) {
-      if (err instanceof MigrationError) throw err;
-      throw new MigrationError(
-        `Failed to compile migration source: ${err.message}`
-      );
+
+// src/internal/firestore-backend.ts
+function buildFirestoreUpdate(update, db) {
+  const out = {
+    updatedAt: FieldValue.serverTimestamp()
+  };
+  if (update.replaceData) {
+    out.data = deserializeFirestoreTypes(update.replaceData, db);
+  }
+  if (update.dataFields) {
+    for (const [k, v] of Object.entries(update.dataFields)) {
+      out[`data.${k}`] = v;
     }
-    return;
   }
-  await sendToWorker({ type: "compile", source });
-}
-function compileMigrationFn(source, executor = defaultExecutor) {
-  const cache = getExecutorCache(executor);
-  const key = hashSource(source);
-  const cached = cache.get(key);
-  if (cached) return cached;
-  try {
-    const fn = executor(source);
-    cache.set(key, fn);
-    return fn;
-  } catch (err) {
-    if (err instanceof MigrationError) throw err;
-    throw new MigrationError(
-      `Failed to compile migration source: ${err.message}`
-    );
+  if (update.v !== void 0) {
+    out.v = update.v;
   }
+  return out;
 }
-function compileMigrations(stored, executor) {
-  return stored.map((step) => ({
-    fromVersion: step.fromVersion,
-    toVersion: step.toVersion,
-    up: compileMigrationFn(step.up, executor)
-  }));
-}
-async function destroySandboxWorker() {
-  if (!_worker) return;
-  const w = _worker;
-  _worker = null;
-  for (const [, p] of _pending) {
-    p.reject(new MigrationError("Sandbox worker terminated"));
-  }
-  _pending.clear();
-  await w.terminate();
+function stampWritableRecord(record) {
+  const now = FieldValue.serverTimestamp();
+  const out = {
+    aType: record.aType,
+    aUid: record.aUid,
+    axbType: record.axbType,
+    bType: record.bType,
+    bUid: record.bUid,
+    data: record.data,
+    createdAt: now,
+    updatedAt: now
+  };
+  if (record.v !== void 0) out.v = record.v;
+  return out;
 }
-
-// src/dynamic-registry.ts
-var META_NODE_TYPE = "nodeType";
-var META_EDGE_TYPE = "edgeType";
-var STORED_MIGRATION_STEP_SCHEMA = {
-  type: "object",
-  required: ["fromVersion", "toVersion", "up"],
-  properties: {
-    fromVersion: { type: "integer", minimum: 0 },
-    toVersion: { type: "integer", minimum: 1 },
-    up: { type: "string", minLength: 1 }
-  },
-  additionalProperties: false
-};
-var NODE_TYPE_SCHEMA = {
-  type: "object",
-  required: ["name", "jsonSchema"],
-  properties: {
-    name: { type: "string", minLength: 1 },
-    jsonSchema: { type: "object" },
-    description: { type: "string" },
-    titleField: { type: "string" },
-    subtitleField: { type: "string" },
-    viewTemplate: { type: "string" },
-    viewCss: { type: "string" },
-    allowedIn: { type: "array", items: { type: "string", minLength: 1 } },
-    schemaVersion: { type: "integer", minimum: 0 },
-    migrations: { type: "array", items: STORED_MIGRATION_STEP_SCHEMA },
-    migrationWriteBack: { type: "string", enum: ["off", "eager", "background"] }
-  },
-  additionalProperties: false
-};
-var EDGE_TYPE_SCHEMA = {
-  type: "object",
-  required: ["name", "from", "to"],
-  properties: {
-    name: { type: "string", minLength: 1 },
-    from: {
-      oneOf: [
-        { type: "string", minLength: 1 },
-        { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 }
-      ]
-    },
-    to: {
-      oneOf: [
-        { type: "string", minLength: 1 },
-        { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 }
-      ]
-    },
-    jsonSchema: { type: "object" },
-    inverseLabel: { type: "string" },
-    description: { type: "string" },
-    titleField: { type: "string" },
-    subtitleField: { type: "string" },
-    viewTemplate: { type: "string" },
-    viewCss: { type: "string" },
-    allowedIn: { type: "array", items: { type: "string", minLength: 1 } },
-    targetGraph: { type: "string", minLength: 1, pattern: "^[^/]+$" },
-    schemaVersion: { type: "integer", minimum: 0 },
-    migrations: { type: "array", items: STORED_MIGRATION_STEP_SCHEMA },
-    migrationWriteBack: { type: "string", enum: ["off", "eager", "background"] }
-  },
-  additionalProperties: false
+var FirestoreTransactionBackend = class {
+  constructor(adapter, db) {
+    this.adapter = adapter;
+    this.db = db;
+  }
+  getDoc(docId) {
+    return this.adapter.getDoc(docId);
+  }
+  query(filters, options) {
+    return this.adapter.query(filters, options);
+  }
+  async setDoc(docId, record) {
+    this.adapter.setDoc(docId, stampWritableRecord(record));
+  }
+  async updateDoc(docId, update) {
+    this.adapter.updateDoc(docId, buildFirestoreUpdate(update, this.db));
+  }
+  async deleteDoc(docId) {
+    this.adapter.deleteDoc(docId);
+  }
 };
-var BOOTSTRAP_ENTRIES = [
-  {
-    aType: META_NODE_TYPE,
-    axbType: NODE_RELATION,
-    bType: META_NODE_TYPE,
-    jsonSchema: NODE_TYPE_SCHEMA,
-    description: "Meta-type: defines a node type"
-  },
-  {
-    aType: META_EDGE_TYPE,
-    axbType: NODE_RELATION,
-    bType: META_EDGE_TYPE,
-    jsonSchema: EDGE_TYPE_SCHEMA,
-    description: "Meta-type: defines an edge type"
+var FirestoreBatchBackend = class {
+  constructor(adapter, db) {
+    this.adapter = adapter;
+    this.db = db;
   }
-];
-function createBootstrapRegistry() {
-  return createRegistry([...BOOTSTRAP_ENTRIES]);
-}
-function generateDeterministicUid(metaType, name) {
-  const hash = createHash3("sha256").update(`${metaType}:${name}`).digest("base64url");
-  return hash.slice(0, 21);
-}
-async function createRegistryFromGraph(reader, executor) {
-  const [nodeTypes, edgeTypes] = await Promise.all([
-    reader.findNodes({ aType: META_NODE_TYPE }),
-    reader.findNodes({ aType: META_EDGE_TYPE })
-  ]);
-  const entries = [...BOOTSTRAP_ENTRIES];
-  const prevalidations = [];
-  for (const record of nodeTypes) {
-    const data = record.data;
-    if (data.migrations) {
-      for (const m of data.migrations) {
-        prevalidations.push(precompileSource(m.up, executor));
-      }
-    }
+  setDoc(docId, record) {
+    this.adapter.setDoc(docId, stampWritableRecord(record));
   }
-  for (const record of edgeTypes) {
-    const data = record.data;
-    if (data.migrations) {
-      for (const m of data.migrations) {
-        prevalidations.push(precompileSource(m.up, executor));
-      }
-    }
+  updateDoc(docId, update) {
+    this.adapter.updateDoc(docId, buildFirestoreUpdate(update, this.db));
   }
-  await Promise.all(prevalidations);
-  for (const record of nodeTypes) {
-    const data = record.data;
-    entries.push({
-      aType: data.name,
-      axbType: NODE_RELATION,
-      bType: data.name,
-      jsonSchema: data.jsonSchema,
-      description: data.description,
-      titleField: data.titleField,
-      subtitleField: data.subtitleField,
-      allowedIn: data.allowedIn,
-      migrations: data.migrations ? compileMigrations(data.migrations, executor) : void 0,
-      migrationWriteBack: data.migrationWriteBack
-    });
+  deleteDoc(docId) {
+    this.adapter.deleteDoc(docId);
   }
-  for (const record of edgeTypes) {
-    const data = record.data;
-    const fromTypes = Array.isArray(data.from) ? data.from : [data.from];
-    const toTypes = Array.isArray(data.to) ? data.to : [data.to];
-    const compiledMigrations = data.migrations ? compileMigrations(data.migrations, executor) : void 0;
-    for (const aType of fromTypes) {
-      for (const bType of toTypes) {
-        entries.push({
-          aType,
-          axbType: data.name,
-          bType,
-          jsonSchema: data.jsonSchema,
-          description: data.description,
-          inverseLabel: data.inverseLabel,
-          titleField: data.titleField,
-          subtitleField: data.subtitleField,
-          allowedIn: data.allowedIn,
-          targetGraph: data.targetGraph,
-          migrations: compiledMigrations,
-          migrationWriteBack: data.migrationWriteBack
-        });
-      }
-    }
+  commit() {
+    return this.adapter.commit();
   }
-  return createRegistry(entries);
-}
-
-// src/client.ts
-var _standardModeWarned = false;
-var RESERVED_TYPE_NAMES = /* @__PURE__ */ new Set([META_NODE_TYPE, META_EDGE_TYPE]);
-var GraphClientImpl = class _GraphClientImpl {
-  constructor(db, collectionPath, options, scopePath = "") {
+};
+var FirestoreBackendImpl = class _FirestoreBackendImpl {
+  constructor(db, collectionPath, queryMode, scopePath) {
     this.db = db;
+    this.queryMode = queryMode;
+    this.collectionPath = collectionPath;
     this.scopePath = scopePath;
     this.adapter = createFirestoreAdapter(db, collectionPath);
-    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;
-      }
-      const metaCollectionPath = options.registryMode.collection;
-      if (metaCollectionPath && metaCollectionPath !== collectionPath) {
-        this.metaAdapter = createFirestoreAdapter(db, metaCollectionPath);
-      }
-    } else {
-      this.staticRegistry = options?.registry;
-    }
-    const requestedMode = options?.queryMode ?? "pipeline";
-    const isEmulator = !!process.env.FIRESTORE_EMULATOR_HOST;
-    if (isEmulator) {
-      this.queryMode = "standard";
-    } else {
-      this.queryMode = requestedMode;
-    }
-    if (this.queryMode === "standard" && !isEmulator && requestedMode === "standard" && !_standardModeWarned) {
-      _standardModeWarned = true;
-      console.warn(
-        "[firegraph] Standard query mode enabled. This is NOT recommended for production:\n  - Enterprise Firestore: data.* filters cause full collection scans (high billing)\n  - Standard Firestore: data.* filters without composite indexes will fail\n  See: https://github.com/typicalday/firegraph#query-modes"
-      );
-    }
-    this.scanProtection = options?.scanProtection ?? "error";
-    if (this.queryMode === "pipeline") {
+    if (queryMode === "pipeline") {
       this.pipelineAdapter = createPipelineQueryAdapter(db, collectionPath);
-      if (this.metaAdapter) {
-        this.metaPipelineAdapter = createPipelineQueryAdapter(
-          db,
-          options.registryMode.collection
-        );
-      }
     }
   }
+  collectionPath;
+  scopePath;
   adapter;
   pipelineAdapter;
-  queryMode;
-  scanProtection;
-  // Static mode
-  staticRegistry;
-  // Dynamic mode
-  dynamicConfig;
-  bootstrapRegistry;
-  dynamicRegistry;
-  metaAdapter;
-  metaPipelineAdapter;
-  // Subgraph scope tracking
-  scopePath;
-  // Migration settings
-  globalWriteBack;
-  migrationSandbox;
-  // ---------------------------------------------------------------------------
-  // Registry routing
-  // ---------------------------------------------------------------------------
-  /**
-   * Get the appropriate registry for validating a write to the given type.
-   *
-   * - Static-only mode: returns staticRegistry (or undefined if none set)
-   * - Dynamic mode (pure or merged):
-   *   - Meta-types (nodeType, edgeType): validated against bootstrapRegistry
-   *   - Domain types: validated against dynamicRegistry (falls back to
-   *     bootstrapRegistry which rejects unknown types)
-   *   - Merged mode: dynamicRegistry is a merged wrapper (static + dynamic
-   *     extension), so static entries take priority automatically.
-   */
-  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;
-  }
-  /**
-   * Get the Firestore adapter for writing the given type.
-   * Meta-types route to metaAdapter if a separate collection is configured.
-   */
-  getAdapterForType(aType) {
-    if (this.metaAdapter && (aType === META_NODE_TYPE || aType === META_EDGE_TYPE)) {
-      return this.metaAdapter;
-    }
-    return this.adapter;
-  }
-  /**
-   * Get the combined registry for transaction/batch context.
-   * In static-only mode, returns staticRegistry.
-   * In dynamic mode, returns dynamicRegistry (which includes bootstrap entries)
-   * or falls back to staticRegistry (merged mode) or bootstrapRegistry.
-   */
-  getCombinedRegistry() {
-    if (!this.dynamicConfig) return this.staticRegistry;
-    return this.dynamicRegistry ?? this.staticRegistry ?? this.bootstrapRegistry;
+  // --- Reads ---
+  getDoc(docId) {
+    return this.adapter.getDoc(docId);
   }
-  // ---------------------------------------------------------------------------
-  // Query dispatch
-  // ---------------------------------------------------------------------------
-  /**
-   * Dispatch a query to the appropriate adapter based on queryMode.
-   * Pipeline queries use the PipelineQueryAdapter; standard queries
-   * use the FirestoreAdapter.
-   */
-  executeQuery(filters, options) {
+  query(filters, options) {
     if (this.pipelineAdapter) {
       return this.pipelineAdapter.query(filters, options);
     }
     return this.adapter.query(filters, options);
   }
-  /**
-   * Check whether a query's filter set is safe (matches a known index pattern).
-   * Throws QuerySafetyError or logs a warning depending on scanProtection config.
-   */
-  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
-  // ---------------------------------------------------------------------------
-  /**
-   * Apply migration to a single record. Returns the (possibly migrated)
-   * record and triggers write-back if applicable.
-   */
-  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;
-  }
-  /**
-   * Apply migrations to an array of records. Returns all records
-   * (migrated where applicable) and triggers write-backs.
-   */
-  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);
-  }
-  /**
-   * Handle write-back for a migrated record based on the resolved mode.
-   *
-   * Both `'eager'` and `'background'` are fire-and-forget (not awaited by
-   * the caller). The difference is logging level on failure:
-   * - `eager`: logs an error via `console.error`
-   * - `background`: logs a warning via `console.warn`
-   *
-   * For truly synchronous write-back guarantees, use transactions — the
-   * `GraphTransactionImpl` performs write-back inline within the transaction.
-   */
-  handleWriteBack(result, docId) {
-    if (result.writeBack === "off") return;
-    const doWriteBack = async () => {
-      try {
-        const update = {
-          data: deserializeFirestoreTypes(result.record.data, this.db),
-          updatedAt: FieldValue5.serverTimestamp()
-        };
-        if (result.record.v !== void 0) {
-          update.v = result.record.v;
-        }
-        await this.adapter.updateDoc(docId, update);
-      } 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.adapter.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.adapter.getDoc(docId);
-    if (!record) return null;
-    return this.applyMigration(record, docId);
-  }
-  async edgeExists(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = await this.adapter.getDoc(docId);
-    return record !== null;
-  }
-  async findEdges(params) {
-    const plan = buildEdgeQueryPlan(params);
-    let records;
-    if (plan.strategy === "get") {
-      const record = await this.adapter.getDoc(plan.docId);
-      records = record ? [record] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.executeQuery(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.adapter.getDoc(plan.docId);
-      records = record ? [record] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.executeQuery(plan.filters, plan.options);
-    }
-    return this.applyMigrations(records);
-  }
-  // ---------------------------------------------------------------------------
-  // GraphWriter
-  // ---------------------------------------------------------------------------
-  async putNode(aType, uid, data) {
-    const registry = this.getRegistryForType(aType);
-    if (registry) {
-      registry.validate(aType, NODE_RELATION, aType, data, this.scopePath);
-    }
-    const adapter = this.getAdapterForType(aType);
-    const docId = computeNodeDocId(uid);
-    const record = buildNodeRecord(aType, uid, data);
-    if (registry) {
-      const entry = registry.lookup(aType, NODE_RELATION, aType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record.v = entry.schemaVersion;
-      }
-    }
-    await adapter.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.scopePath);
-    }
-    const adapter = this.getAdapterForType(aType);
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record = buildEdgeRecord(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 adapter.setDoc(docId, record);
-  }
-  async updateNode(uid, data) {
-    const docId = computeNodeDocId(uid);
-    const update = {
-      updatedAt: FieldValue5.serverTimestamp()
-    };
-    for (const [k, v] of Object.entries(data)) {
-      update[`data.${k}`] = v;
-    }
-    await this.adapter.updateDoc(docId, update);
+  // --- Writes ---
+  setDoc(docId, record) {
+    return this.adapter.setDoc(docId, stampWritableRecord(record));
   }
-  async removeNode(uid) {
-    const docId = computeNodeDocId(uid);
-    await this.adapter.deleteDoc(docId);
+  updateDoc(docId, update) {
+    return this.adapter.updateDoc(docId, buildFirestoreUpdate(update, this.db));
   }
-  async removeEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    await this.adapter.deleteDoc(docId);
+  deleteDoc(docId) {
+    return this.adapter.deleteDoc(docId);
   }
-  // ---------------------------------------------------------------------------
-  // Transactions & Batches
-  // ---------------------------------------------------------------------------
-  async runTransaction(fn) {
+  // --- Transactions / Batches ---
+  runTransaction(fn) {
     return this.db.runTransaction(async (firestoreTx) => {
-      const adapter = createTransactionAdapter(
-        this.db,
-        this.adapter.collectionPath,
-        firestoreTx
-      );
-      const graphTx = new GraphTransactionImpl(adapter, this.getCombinedRegistry(), this.scanProtection, this.scopePath, this.globalWriteBack, this.db);
-      return fn(graphTx);
+      const txAdapter = createTransactionAdapter(this.db, this.collectionPath, firestoreTx);
+      return fn(new FirestoreTransactionBackend(txAdapter, this.db));
     });
   }
-  batch() {
-    const adapter = createBatchAdapter(this.db, this.adapter.collectionPath);
-    return new GraphBatchImpl(adapter, this.getCombinedRegistry(), this.scopePath);
+  createBatch() {
+    const batchAdapter = createBatchAdapter(this.db, this.collectionPath);
+    return new FirestoreBatchBackend(batchAdapter, this.db);
   }
-  // ---------------------------------------------------------------------------
-  // 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 subCollectionPath = `${this.adapter.collectionPath}/${parentNodeUid}/${name}`;
-    const newScopePath = this.scopePath ? `${this.scopePath}/${name}` : name;
-    return new _GraphClientImpl(
-      this.db,
-      subCollectionPath,
-      {
-        registry: this.getCombinedRegistry(),
-        queryMode: this.queryMode === "pipeline" ? "pipeline" : "standard",
-        scanProtection: this.scanProtection,
-        migrationWriteBack: this.globalWriteBack,
-        migrationSandbox: this.migrationSandbox
-      },
-      newScopePath
-    );
+  // --- Subgraphs ---
+  subgraph(parentNodeUid, name) {
+    const subPath = `${this.collectionPath}/${parentNodeUid}/${name}`;
+    const newScope = this.scopePath ? `${this.scopePath}/${name}` : name;
+    return new _FirestoreBackendImpl(this.db, subPath, this.queryMode, newScope);
+  }
+  // --- Cascade & bulk ---
+  removeNodeCascade(uid, reader, options) {
+    return removeNodeCascade(this.db, this.collectionPath, reader, uid, options);
   }
-  // ---------------------------------------------------------------------------
-  // Collection group query
-  // ---------------------------------------------------------------------------
+  bulkRemoveEdges(params, reader, options) {
+    return bulkRemoveEdges(this.db, this.collectionPath, reader, params, options);
+  }
+  // --- Cross-collection ---
   async findEdgesGlobal(params, collectionName) {
-    const name = collectionName ?? this.adapter.collectionPath.split("/").pop();
+    const name = collectionName ?? this.collectionPath.split("/").pop();
     const plan = buildEdgeQueryPlan(params);
     if (plan.strategy === "get") {
       throw new FiregraphError(
@@ -1970,7 +733,6 @@ var GraphClientImpl = class _GraphClientImpl {
         "INVALID_QUERY"
       );
     }
-    this.checkQuerySafety(plan.filters, params.allowCollectionScan);
     const collectionGroupRef = this.db.collectionGroup(name);
     let q = collectionGroupRef;
     for (const f of plan.filters) {
@@ -1983,170 +745,35 @@ var GraphClientImpl = class _GraphClientImpl {
       q = q.limit(plan.options.limit);
     }
     const snap = await q.get();
-    const records = snap.docs.map((doc) => doc.data());
-    return this.applyMigrations(records);
-  }
-  // ---------------------------------------------------------------------------
-  // Bulk operations
-  // ---------------------------------------------------------------------------
-  async removeNodeCascade(uid, options) {
-    return removeNodeCascade(this.db, this.adapter.collectionPath, this, uid, options);
-  }
-  async bulkRemoveEdges(params, options) {
-    return bulkRemoveEdges(this.db, this.adapter.collectionPath, this, params, options);
-  }
-  // ---------------------------------------------------------------------------
-  // 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);
-  }
-  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);
-  }
-  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;
-    }
+    return snap.docs.map((doc) => doc.data());
   }
-  /**
-   * Serialize migration steps for storage in Firestore.
-   * Function objects are converted via `.toString()`; strings are stored as-is.
-   * Each migration is validated at define-time by pre-compiling in the sandbox.
-   */
-  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))
+};
+function createFirestoreBackend(db, collectionPath, options = {}) {
+  const queryMode = options.queryMode ?? "pipeline";
+  const scopePath = options.scopePath ?? "";
+  return new FirestoreBackendImpl(db, collectionPath, queryMode, scopePath);
+}
+
+// src/firestore.ts
+var _standardModeWarned = false;
+function createGraphClient(db, collectionPath, options) {
+  const requestedMode = options?.queryMode ?? "pipeline";
+  const isEmulator = !!process.env.FIRESTORE_EMULATOR_HOST;
+  const effectiveMode = isEmulator ? "standard" : requestedMode;
+  if (effectiveMode === "standard" && !isEmulator && requestedMode === "standard" && !_standardModeWarned) {
+    _standardModeWarned = true;
+    console.warn(
+      "[firegraph] Standard query mode enabled. This is NOT recommended for production:\n  - Enterprise Firestore: data.* filters cause full collection scans (high billing)\n  - Standard Firestore: data.* filters without composite indexes will fail\n  See: https://github.com/typicalday/firegraph#query-modes"
     );
-    return result;
   }
-  /**
-   * Create a GraphReader for the meta-collection.
-   * If meta-collection is the same as main collection, returns `this`.
-   * If separate, creates a lightweight reader wrapping the meta adapter.
-   */
-  createMetaReader() {
-    if (!this.metaAdapter) return this;
-    const adapter = this.metaAdapter;
-    const pipelineAdapter = this.metaPipelineAdapter;
-    const executeMetaQuery = (filters, options) => {
-      if (pipelineAdapter) return pipelineAdapter.query(filters, options);
-      return adapter.query(filters, options);
-    };
-    return {
-      async getNode(uid) {
-        return adapter.getDoc(computeNodeDocId(uid));
-      },
-      async getEdge(aUid, axbType, bUid) {
-        return adapter.getDoc(computeEdgeDocId(aUid, axbType, bUid));
-      },
-      async edgeExists(aUid, axbType, bUid) {
-        const record = await adapter.getDoc(computeEdgeDocId(aUid, axbType, bUid));
-        return record !== null;
-      },
-      async findEdges(params) {
-        const plan = buildEdgeQueryPlan(params);
-        if (plan.strategy === "get") {
-          const record = await adapter.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 adapter.getDoc(plan.docId);
-          return record ? [record] : [];
-        }
-        return executeMetaQuery(plan.filters, plan.options);
-      }
-    };
+  const backend = createFirestoreBackend(db, collectionPath, { queryMode: effectiveMode });
+  let metaBackend;
+  if (options?.registryMode?.collection && options.registryMode.collection !== collectionPath) {
+    metaBackend = createFirestoreBackend(db, options.registryMode.collection, {
+      queryMode: effectiveMode
+    });
   }
-};
-function createGraphClient(db, collectionPath, options) {
-  return new GraphClientImpl(db, collectionPath, options);
+  return new GraphClientImpl(backend, options, metaBackend);
 }
 
 // src/id.ts
@@ -2155,22 +782,175 @@ function generateId() {
   return nanoid();
 }
 
-// src/traverse.ts
-var DEFAULT_LIMIT = 10;
-var DEFAULT_MAX_READS = 100;
-var DEFAULT_CONCURRENCY = 5;
-var _crossGraphWarned = false;
-function isGraphClient(reader) {
-  return "subgraph" in reader && typeof reader.subgraph === "function";
-}
-var Semaphore = class {
-  constructor(slots) {
-    this.slots = slots;
-  }
-  queue = [];
-  active = 0;
-  async acquire() {
-    if (this.active < this.slots) {
+// src/indexes.ts
+function baseIndexes(collection) {
+  return [
+    {
+      collectionGroup: collection,
+      queryScope: "COLLECTION",
+      fields: [
+        { fieldPath: "aUid", order: "ASCENDING" },
+        { fieldPath: "axbType", order: "ASCENDING" }
+      ]
+    },
+    {
+      collectionGroup: collection,
+      queryScope: "COLLECTION",
+      fields: [
+        { fieldPath: "axbType", order: "ASCENDING" },
+        { fieldPath: "bUid", order: "ASCENDING" }
+      ]
+    },
+    {
+      collectionGroup: collection,
+      queryScope: "COLLECTION",
+      fields: [
+        { fieldPath: "aType", order: "ASCENDING" },
+        { fieldPath: "axbType", order: "ASCENDING" }
+      ]
+    },
+    {
+      collectionGroup: collection,
+      queryScope: "COLLECTION",
+      fields: [
+        { fieldPath: "axbType", order: "ASCENDING" },
+        { fieldPath: "bType", order: "ASCENDING" }
+      ]
+    }
+  ];
+}
+function extractSchemaFields(schema) {
+  const s = schema;
+  if (s.type !== "object" || !s.properties) return [];
+  return Object.keys(s.properties);
+}
+function collectionGroupIndexes(collectionName) {
+  return [
+    {
+      collectionGroup: collectionName,
+      queryScope: "COLLECTION_GROUP",
+      fields: [
+        { fieldPath: "aUid", order: "ASCENDING" },
+        { fieldPath: "axbType", order: "ASCENDING" }
+      ]
+    },
+    {
+      collectionGroup: collectionName,
+      queryScope: "COLLECTION_GROUP",
+      fields: [
+        { fieldPath: "axbType", order: "ASCENDING" },
+        { fieldPath: "bUid", order: "ASCENDING" }
+      ]
+    },
+    {
+      collectionGroup: collectionName,
+      queryScope: "COLLECTION_GROUP",
+      fields: [
+        { fieldPath: "aType", order: "ASCENDING" },
+        { fieldPath: "axbType", order: "ASCENDING" }
+      ]
+    },
+    {
+      collectionGroup: collectionName,
+      queryScope: "COLLECTION_GROUP",
+      fields: [
+        { fieldPath: "axbType", order: "ASCENDING" },
+        { fieldPath: "bType", order: "ASCENDING" }
+      ]
+    }
+  ];
+}
+function generateIndexConfig(collection, entities, registryEntries) {
+  const indexes = baseIndexes(collection);
+  if (entities) {
+    for (const [, entity] of entities.nodes) {
+      const fields = extractSchemaFields(entity.schema);
+      for (const field of fields) {
+        indexes.push({
+          collectionGroup: collection,
+          queryScope: "COLLECTION",
+          fields: [
+            { fieldPath: "aType", order: "ASCENDING" },
+            { fieldPath: "axbType", order: "ASCENDING" },
+            { fieldPath: `data.${field}`, order: "ASCENDING" }
+          ]
+        });
+      }
+    }
+    for (const [, entity] of entities.edges) {
+      const fields = extractSchemaFields(entity.schema);
+      for (const field of fields) {
+        indexes.push({
+          collectionGroup: collection,
+          queryScope: "COLLECTION",
+          fields: [
+            { fieldPath: "aUid", order: "ASCENDING" },
+            { fieldPath: "axbType", order: "ASCENDING" },
+            { fieldPath: `data.${field}`, order: "ASCENDING" }
+          ]
+        });
+      }
+    }
+  }
+  if (registryEntries) {
+    const targetGraphNames = /* @__PURE__ */ new Set();
+    for (const entry of registryEntries) {
+      if (entry.targetGraph) {
+        targetGraphNames.add(entry.targetGraph);
+      }
+    }
+    for (const name of targetGraphNames) {
+      indexes.push(...collectionGroupIndexes(name));
+    }
+  }
+  return { indexes, fieldOverrides: [] };
+}
+
+// src/record.ts
+import { FieldValue as FieldValue2 } from "@google-cloud/firestore";
+function buildNodeRecord(aType, uid, data) {
+  const now = FieldValue2.serverTimestamp();
+  return {
+    aType,
+    aUid: uid,
+    axbType: NODE_RELATION,
+    bType: aType,
+    bUid: uid,
+    data,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function buildEdgeRecord(aType, aUid, axbType, bType, bUid, data) {
+  const now = FieldValue2.serverTimestamp();
+  return {
+    aType,
+    aUid,
+    axbType,
+    bType,
+    bUid,
+    data,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+
+// src/traverse.ts
+var DEFAULT_LIMIT = 10;
+var DEFAULT_MAX_READS = 100;
+var DEFAULT_CONCURRENCY = 5;
+var _crossGraphWarned = false;
+function isGraphClient(reader) {
+  return "subgraph" in reader && typeof reader.subgraph === "function";
+}
+var Semaphore = class {
+  constructor(slots) {
+    this.slots = slots;
+  }
+  queue = [];
+  active = 0;
+  async acquire() {
+    if (this.active < this.slots) {
       this.active++;
       return;
     }
@@ -2359,7 +1139,6 @@ function getCustomElements() {
 function resilientView(ViewClass, tagName) {
   const g = globalThis;
   if (!g.HTMLElement) return ViewClass;
-  const Base = g.HTMLElement;
   const Wrapped = class extends ViewClass {
     connectedCallback() {
       try {
@@ -2444,369 +1223,9 @@ function defineViews(input) {
   }
   return { nodes, edges };
 }
-
-// src/config.ts
-function defineConfig(config) {
-  return config;
-}
-function resolveView(resolverConfig, availableViewNames, context) {
-  if (!resolverConfig) return "json";
-  const available = new Set(availableViewNames);
-  if (context) {
-    const contextDefault = resolverConfig[context];
-    if (contextDefault && available.has(contextDefault)) {
-      return contextDefault;
-    }
-  }
-  if (resolverConfig.default && available.has(resolverConfig.default)) {
-    return resolverConfig.default;
-  }
-  return "json";
-}
-
-// src/discover.ts
-import { readFileSync, readdirSync, existsSync, statSync } from "fs";
-import { createRequire } from "module";
-import { join, resolve } from "path";
-var DiscoveryError = class extends FiregraphError {
-  constructor(message) {
-    super(message, "DISCOVERY_ERROR");
-    this.name = "DiscoveryError";
-  }
-};
-function readJson(filePath) {
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    return JSON.parse(raw);
-  } catch (err) {
-    const msg = err instanceof SyntaxError ? `Invalid JSON in ${filePath}: ${err.message}` : `Cannot read ${filePath}: ${err.message}`;
-    throw new DiscoveryError(msg);
-  }
-}
-function readJsonIfExists(filePath) {
-  if (!existsSync(filePath)) return void 0;
-  return readJson(filePath);
-}
-var SCHEMA_SCRIPT_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
-function loadSchema(dir, entityLabel) {
-  for (const ext of SCHEMA_SCRIPT_EXTENSIONS) {
-    const candidate = join(dir, `schema${ext}`);
-    if (existsSync(candidate)) {
-      return loadSchemaModule(candidate, entityLabel);
-    }
-  }
-  const jsonPath = join(dir, "schema.json");
-  if (existsSync(jsonPath)) {
-    return readJson(jsonPath);
-  }
-  throw new DiscoveryError(
-    `Missing schema for ${entityLabel} in ${dir}. Provide a schema.ts (or .js/.mts/.mjs) or schema.json file.`
-  );
-}
-var _jiti;
-function getJiti() {
-  if (!_jiti) {
-    const base = typeof __filename !== "undefined" ? __filename : import.meta.url;
-    const esmRequire = createRequire(base);
-    const { createJiti } = esmRequire("jiti");
-    _jiti = createJiti(base, { interopDefault: true });
-  }
-  return _jiti;
-}
-function loadSchemaModule(filePath, entityLabel) {
-  try {
-    const jiti = getJiti();
-    const mod = jiti(filePath);
-    const schema = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
-    if (!schema || typeof schema !== "object") {
-      throw new DiscoveryError(
-        `Schema file ${filePath} for ${entityLabel} must default-export a JSON Schema object.`
-      );
-    }
-    return schema;
-  } catch (err) {
-    if (err instanceof DiscoveryError) throw err;
-    throw new DiscoveryError(
-      `Failed to load schema module ${filePath} for ${entityLabel}: ${err.message}`
-    );
-  }
-}
-var VIEW_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
-function findViewsFile(dir) {
-  for (const ext of VIEW_EXTENSIONS) {
-    const candidate = join(dir, `views${ext}`);
-    if (existsSync(candidate)) return candidate;
-  }
-  return void 0;
-}
-var MIGRATION_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
-function findMigrationsFile(dir) {
-  for (const ext of MIGRATION_EXTENSIONS) {
-    const candidate = join(dir, `migrations${ext}`);
-    if (existsSync(candidate)) return candidate;
-  }
-  return void 0;
-}
-function loadMigrations(filePath, entityLabel) {
-  try {
-    const jiti = getJiti();
-    const mod = jiti(filePath);
-    const migrations = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
-    if (!Array.isArray(migrations)) {
-      throw new DiscoveryError(
-        `Migrations file ${filePath} for ${entityLabel} must default-export an array of MigrationStep.`
-      );
-    }
-    return migrations;
-  } catch (err) {
-    if (err instanceof DiscoveryError) throw err;
-    throw new DiscoveryError(
-      `Failed to load migrations ${filePath} for ${entityLabel}: ${err.message}`
-    );
-  }
-}
-function loadNodeEntity(dir, name) {
-  const schema = loadSchema(dir, `node type "${name}"`);
-  const meta = readJsonIfExists(join(dir, "meta.json"));
-  const sampleData = readJsonIfExists(join(dir, "sample.json"));
-  const viewsPath = findViewsFile(dir);
-  const migrationsPath = findMigrationsFile(dir);
-  const migrations = migrationsPath ? loadMigrations(migrationsPath, `node type "${name}"`) : void 0;
-  return {
-    kind: "node",
-    name,
-    schema,
-    description: meta?.description,
-    titleField: meta?.titleField,
-    subtitleField: meta?.subtitleField,
-    viewDefaults: meta?.viewDefaults,
-    viewsPath,
-    sampleData,
-    allowedIn: meta?.allowedIn,
-    migrations,
-    migrationWriteBack: meta?.migrationWriteBack
-  };
-}
-function loadEdgeEntity(dir, name) {
-  const schema = loadSchema(dir, `edge type "${name}"`);
-  const edgePath = join(dir, "edge.json");
-  if (!existsSync(edgePath)) {
-    throw new DiscoveryError(
-      `Missing edge.json for edge type "${name}" in ${dir}. Edge entities must declare topology (from/to node types).`
-    );
-  }
-  const topology = readJson(edgePath);
-  if (!topology.from) {
-    throw new DiscoveryError(
-      `edge.json for "${name}" is missing required "from" field`
-    );
-  }
-  if (!topology.to) {
-    throw new DiscoveryError(
-      `edge.json for "${name}" is missing required "to" field`
-    );
-  }
-  const meta = readJsonIfExists(join(dir, "meta.json"));
-  const sampleData = readJsonIfExists(join(dir, "sample.json"));
-  const viewsPath = findViewsFile(dir);
-  const migrationsPath = findMigrationsFile(dir);
-  const migrations = migrationsPath ? loadMigrations(migrationsPath, `edge type "${name}"`) : void 0;
-  return {
-    kind: "edge",
-    name,
-    schema,
-    topology,
-    description: meta?.description,
-    titleField: meta?.titleField,
-    subtitleField: meta?.subtitleField,
-    viewDefaults: meta?.viewDefaults,
-    viewsPath,
-    sampleData,
-    allowedIn: meta?.allowedIn,
-    targetGraph: topology.targetGraph ?? meta?.targetGraph,
-    migrations,
-    migrationWriteBack: meta?.migrationWriteBack
-  };
-}
-function getSubdirectories(dir) {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-}
-function discoverEntities(entitiesDir) {
-  const absDir = resolve(entitiesDir);
-  if (!existsSync(absDir) || !statSync(absDir).isDirectory()) {
-    throw new DiscoveryError(`Entities directory not found: ${entitiesDir}`);
-  }
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  const warnings = [];
-  const nodesDir = join(absDir, "nodes");
-  for (const name of getSubdirectories(nodesDir)) {
-    nodes.set(name, loadNodeEntity(join(nodesDir, name), name));
-  }
-  const edgesDir = join(absDir, "edges");
-  for (const name of getSubdirectories(edgesDir)) {
-    edges.set(name, loadEdgeEntity(join(edgesDir, name), name));
-  }
-  const nodeNames = new Set(nodes.keys());
-  for (const [axbType, entity] of edges) {
-    const topology = entity.topology;
-    const fromTypes = Array.isArray(topology.from) ? topology.from : [topology.from];
-    const toTypes = Array.isArray(topology.to) ? topology.to : [topology.to];
-    for (const ref of [...fromTypes, ...toTypes]) {
-      if (!nodeNames.has(ref)) {
-        warnings.push({
-          code: "DANGLING_TOPOLOGY_REF",
-          message: `Edge "${axbType}" references node type "${ref}" which was not found in the nodes directory`
-        });
-      }
-    }
-  }
-  return {
-    result: { nodes, edges },
-    warnings
-  };
-}
-
-// src/cross-graph.ts
-function resolveAncestorCollection(collectionPath, uid) {
-  const segments = collectionPath.split("/");
-  for (let i = 1; i < segments.length; i += 2) {
-    if (segments[i] === uid) {
-      return segments.slice(0, i).join("/");
-    }
-  }
-  return null;
-}
-function isAncestorUid(collectionPath, uid) {
-  return resolveAncestorCollection(collectionPath, uid) !== null;
-}
-
-// src/indexes.ts
-function baseIndexes(collection) {
-  return [
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "aUid", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bUid", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "aType", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bType", order: "ASCENDING" }
-      ]
-    }
-  ];
-}
-function extractSchemaFields(schema) {
-  const s = schema;
-  if (s.type !== "object" || !s.properties) return [];
-  return Object.keys(s.properties);
-}
-function collectionGroupIndexes(collectionName) {
-  return [
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "aUid", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bUid", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "aType", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bType", order: "ASCENDING" }
-      ]
-    }
-  ];
-}
-function generateIndexConfig(collection, entities, registryEntries) {
-  const indexes = baseIndexes(collection);
-  if (entities) {
-    for (const [, entity] of entities.nodes) {
-      const fields = extractSchemaFields(entity.schema);
-      for (const field of fields) {
-        indexes.push({
-          collectionGroup: collection,
-          queryScope: "COLLECTION",
-          fields: [
-            { fieldPath: "aType", order: "ASCENDING" },
-            { fieldPath: "axbType", order: "ASCENDING" },
-            { fieldPath: `data.${field}`, order: "ASCENDING" }
-          ]
-        });
-      }
-    }
-    for (const [, entity] of entities.edges) {
-      const fields = extractSchemaFields(entity.schema);
-      for (const field of fields) {
-        indexes.push({
-          collectionGroup: collection,
-          queryScope: "COLLECTION",
-          fields: [
-            { fieldPath: "aUid", order: "ASCENDING" },
-            { fieldPath: "axbType", order: "ASCENDING" },
-            { fieldPath: `data.${field}`, order: "ASCENDING" }
-          ]
-        });
-      }
-    }
-  }
-  if (registryEntries) {
-    const targetGraphNames = /* @__PURE__ */ new Set();
-    for (const entry of registryEntries) {
-      if (entry.targetGraph) {
-        targetGraphNames.add(entry.targetGraph);
-      }
-    }
-    for (const name of targetGraphNames) {
-      indexes.push(...collectionGroupIndexes(name));
-    }
-  }
-  return { indexes, fieldOverrides: [] };
-}
 export {
   BOOTSTRAP_ENTRIES,
+  CrossBackendTransactionError,
   DEFAULT_QUERY_LIMIT,
   DiscoveryError,
   DynamicRegistryError,
@@ -2828,6 +1247,7 @@ export {
   TraversalError,
   ValidationError,
   analyzeQuerySafety,
+  appendStorageScope,
   applyMigrationChain,
   buildEdgeQueryPlan,
   buildEdgeRecord,
@@ -2840,6 +1260,7 @@ export {
   computeNodeDocId,
   createBootstrapRegistry,
   createGraphClient,
+  createGraphClientFromBackend,
   createMergedRegistry,
   createRegistry,
   createRegistryFromGraph,
@@ -2854,6 +1275,7 @@ export {
   generateId,
   generateIndexConfig,
   generateTypes,
+  isAncestorScopeUid,
   isAncestorUid,
   isTaggedValue,
   jsonSchemaToFieldMeta,
@@ -2861,8 +1283,10 @@ export {
   matchScopeAny,
   migrateRecord,
   migrateRecords,
+  parseStorageScope,
   precompileSource,
   resolveAncestorCollection,
+  resolveAncestorScope,
   resolveView,
   serializeFirestoreTypes,
   validateMigrationChain