@typicalday/firegraph 0.7.0 → 0.8.0

package/dist/editor/server/index.mjs

@@ -11,6 +11,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -29633,6 +29636,122 @@ var require_dist = __commonJS({
   }
 });
 
+// src/serialization.ts
+var serialization_exports = {};
+__export(serialization_exports, {
+  SERIALIZATION_TAG: () => SERIALIZATION_TAG,
+  deserializeFirestoreTypes: () => deserializeFirestoreTypes,
+  isTaggedValue: () => isTaggedValue,
+  serializeFirestoreTypes: () => serializeFirestoreTypes
+});
+import { Timestamp, GeoPoint, FieldValue } from "@google-cloud/firestore";
+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);
+}
+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]);
+  }
+  return result;
+}
+function deserializeFirestoreTypes(data, db2) {
+  return deserializeValue(data, db2);
+}
+function deserializeValue(value, db2) {
+  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, db2));
+  }
+  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 FieldValue.vector(obj.values);
+      case "DocumentReference":
+        if (typeof obj.path !== "string") return obj;
+        if (db2) {
+          return db2.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], db2);
+  }
+  return result;
+}
+var SERIALIZATION_TAG, KNOWN_TYPES, _docRefWarned;
+var init_serialization = __esm({
+  "src/serialization.ts"() {
+    "use strict";
+    SERIALIZATION_TAG = "__firegraph_ser__";
+    KNOWN_TYPES = /* @__PURE__ */ new Set(["Timestamp", "GeoPoint", "VectorValue", "DocumentReference"]);
+    _docRefWarned = false;
+  }
+});
+
 // editor/server/index.ts
 var import_express = __toESM(require_express2(), 1);
 var import_cors = __toESM(require_lib3(), 1);
@@ -29640,9 +29759,6 @@ import path4 from "path";
 import { fileURLToPath } from "url";
 import { Firestore } from "@google-cloud/firestore";
 
-// src/client.ts
-import { FieldValue as FieldValue5 } from "@google-cloud/firestore";
-
 // src/docid.ts
 import { createHash } from "node:crypto";
 
@@ -29671,34 +29787,66 @@ function computeEdgeDocId(aUid, axbType, bUid) {
   return `${shard}${SHARD_SEPARATOR}${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
 }
 
-// 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/batch.ts
+function buildWritableNodeRecord(aType, uid, data) {
+  return { aType, aUid: uid, axbType: NODE_RELATION, bType: aType, bUid: uid, data };
 }
-function buildEdgeRecord(aType, aUid, axbType, bType, bUid, data) {
-  const now = FieldValue.serverTimestamp();
-  return {
-    aType,
-    aUid,
-    axbType,
-    bType,
-    bUid,
-    data,
-    createdAt: now,
-    updatedAt: now
-  };
+function buildWritableEdgeRecord(aType, aUid, axbType, bType, bUid, data) {
+  return { aType, aUid, axbType, bType, bUid, data };
 }
+var GraphBatchImpl = class {
+  constructor(backend, registry2, scopePath = "") {
+    this.backend = backend;
+    this.registry = registry2;
+    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 record2 = buildWritableNodeRecord(aType, uid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record2.v = entry.schemaVersion;
+      }
+    }
+    this.backend.setDoc(docId, record2);
+  }
+  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 record2 = buildWritableEdgeRecord(aType, aUid, axbType, bType, bUid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, axbType, bType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record2.v = entry.schemaVersion;
+      }
+    }
+    this.backend.setDoc(docId, record2);
+  }
+  async updateNode(uid, data) {
+    const docId = computeNodeDocId(uid);
+    this.backend.updateDoc(docId, { dataFields: data });
+  }
+  async removeNode(uid) {
+    const docId = computeNodeDocId(uid);
+    this.backend.deleteDoc(docId);
+  }
+  async removeEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    this.backend.deleteDoc(docId);
+  }
+  async commit() {
+    await this.backend.commit();
+  }
+};
+
+// src/dynamic-registry.ts
+import { createHash as createHash3 } from "node:crypto";
 
 // src/errors.ts
 var FiregraphError = class extends Error {
@@ -29758,487 +29906,912 @@ var MigrationError = class extends FiregraphError {
   }
 };
 
-// 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) };
+// src/json-schema.ts
+var import_ajv = __toESM(require_ajv(), 1);
+var import_ajv_formats = __toESM(require_dist(), 1);
+var ajv = new import_ajv.default({ allErrors: true, strict: false });
+(0, import_ajv_formats.default)(ajv);
+function compileSchema(schema, label) {
+  const validate = ajv.compile(schema);
+  return (data) => {
+    if (!validate(data)) {
+      const errors = validate.errors ?? [];
+      const messages = errors.map((err) => `${err.instancePath || "/"}${err.message ? ": " + err.message : ""}`).join("; ");
+      throw new ValidationError(
+        `Data validation failed${label ? " for " + label : ""}: ${messages}`,
+        errors
+      );
+    }
+  };
+}
+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, required2) {
+  if (!prop) return { name, type: "unknown", required: required2 };
+  if (Array.isArray(prop.enum)) {
+    return {
+      name,
+      type: "enum",
+      required: required2,
+      enumValues: prop.enum,
+      description: prop.description
+    };
   }
-  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 });
+  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: required2, description: prop.description };
   }
-  if (filters.length === 0) {
-    throw new InvalidQueryError("findEdges requires at least one filter parameter");
+  const type = prop.type;
+  if (type === "string") {
+    return {
+      name,
+      type: "string",
+      required: required2,
+      minLength: prop.minLength,
+      maxLength: prop.maxLength,
+      pattern: prop.pattern,
+      description: prop.description
+    };
   }
-  const effectiveLimit = limit === void 0 ? DEFAULT_QUERY_LIMIT : limit || void 0;
-  return { strategy: "query", filters, options: { limit: effectiveLimit, orderBy } };
-}
-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 });
-    }
+  if (type === "number" || type === "integer") {
+    return {
+      name,
+      type: "number",
+      required: required2,
+      min: prop.minimum,
+      max: prop.maximum,
+      isInt: type === "integer" ? true : void 0,
+      description: prop.description
+    };
   }
-  const effectiveLimit = limit === void 0 ? DEFAULT_QUERY_LIMIT : limit || void 0;
-  return { strategy: "query", filters, options: { limit: effectiveLimit, orderBy } };
+  if (type === "boolean") {
+    return { name, type: "boolean", required: required2, description: prop.description };
+  }
+  if (type === "array") {
+    const itemMeta = prop.items ? propertyToFieldMeta("item", prop.items, true) : void 0;
+    return {
+      name,
+      type: "array",
+      required: required2,
+      itemMeta,
+      description: prop.description
+    };
+  }
+  if (type === "object") {
+    return {
+      name,
+      type: "object",
+      required: required2,
+      fields: jsonSchemaToFieldMeta(prop),
+      description: prop.description
+    };
+  }
+  return { name, type: "unknown", required: required2, description: prop.description };
 }
 
-// src/internal/firestore-adapter.ts
-function createFirestoreAdapter(db2, collectionPath) {
-  const collectionRef = db2.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");
+// src/migration.ts
+async function applyMigrationChain(data, currentVersion, targetVersion, migrations) {
+  const sorted = [...migrations].sort((a, b) => a.fromVersion - b.fromVersion);
+  let result = { ...data };
+  let version2 = currentVersion;
+  for (const step of sorted) {
+    if (step.fromVersion === version2) {
+      try {
+        result = await step.up(result);
+      } catch (err) {
+        if (err instanceof MigrationError) throw err;
+        throw new MigrationError(
+          `Migration from v${step.fromVersion} to v${step.toVersion} failed: ${err.message}`
+        );
       }
-      if (options?.limit !== void 0) {
-        q = q.limit(options.limit);
+      if (!result || typeof result !== "object") {
+        throw new MigrationError(
+          `Migration from v${step.fromVersion} to v${step.toVersion} returned invalid data (expected object)`
+        );
       }
-      const snap = await q.get();
-      return snap.docs.map((doc) => doc.data());
+      version2 = step.toVersion;
     }
-  };
+  }
+  if (version2 !== targetVersion) {
+    throw new MigrationError(
+      `Incomplete migration chain: reached v${version2} but target is v${targetVersion}`
+    );
+  }
+  return result;
 }
-function createTransactionAdapter(db2, collectionPath, tx) {
-  const collectionRef = db2.collection(collectionPath);
-  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 validateMigrationChain(migrations, label) {
+  if (migrations.length === 0) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const step of migrations) {
+    if (step.toVersion <= step.fromVersion) {
+      throw new MigrationError(
+        `${label}: migration step has toVersion (${step.toVersion}) <= fromVersion (${step.fromVersion})`
+      );
     }
-  };
-}
-function createBatchAdapter(db2, collectionPath) {
-  const collectionRef = db2.collection(collectionPath);
-  const batch = db2.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();
+    if (seen.has(step.fromVersion)) {
+      throw new MigrationError(
+        `${label}: duplicate migration step for fromVersion ${step.fromVersion}`
+      );
     }
-  };
-}
-
-// src/internal/pipeline-adapter.ts
-var _Pipelines = null;
-async function getPipelines() {
-  if (!_Pipelines) {
-    const mod = await import("@google-cloud/firestore");
-    _Pipelines = mod.Pipelines;
+    seen.add(step.fromVersion);
   }
-  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 sorted = [...migrations].sort((a, b) => a.fromVersion - b.fromVersion);
+  const targetVersion = Math.max(...migrations.map((m) => m.toVersion));
+  let version2 = 0;
+  for (const step of sorted) {
+    if (step.fromVersion === version2) {
+      version2 = step.toVersion;
+    } else if (step.fromVersion > version2) {
+      throw new MigrationError(
+        `${label}: migration chain has a gap \u2014 no step covers v${version2} \u2192 v${step.fromVersion}`
+      );
+    }
+  }
+  if (version2 !== targetVersion) {
+    throw new MigrationError(
+      `${label}: migration chain does not reach v${targetVersion} (stuck at v${version2})`
+    );
   }
 }
-function createPipelineQueryAdapter(db2, collectionPath) {
+async function migrateRecord(record2, registry2, globalWriteBack = "off") {
+  const entry = registry2.lookup(record2.aType, record2.axbType, record2.bType);
+  if (!entry?.migrations?.length || !entry.schemaVersion) {
+    return { record: record2, migrated: false, writeBack: "off" };
+  }
+  const currentVersion = record2.v ?? 0;
+  if (currentVersion >= entry.schemaVersion) {
+    return { record: record2, migrated: false, writeBack: "off" };
+  }
+  const migratedData = await applyMigrationChain(
+    record2.data,
+    currentVersion,
+    entry.schemaVersion,
+    entry.migrations
+  );
+  const writeBack = entry.migrationWriteBack ?? globalWriteBack ?? "off";
   return {
-    async query(filters, options) {
-      const P = await getPipelines();
-      let pipeline = db2.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());
-    }
+    record: { ...record2, data: migratedData, v: entry.schemaVersion },
+    migrated: true,
+    writeBack
   };
 }
+async function migrateRecords(records, registry2, globalWriteBack = "off") {
+  return Promise.all(
+    records.map((r) => migrateRecord(r, registry2, globalWriteBack))
+  );
+}
 
-// 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;
-    }
-  }
-  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 };
+// 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(path5, pi, pattern, qi) {
+  if (pi === path5.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 <= path5.length - pi; skip++) {
+      if (matchSegments(path5, pi + skip, pattern, qi + 1)) return true;
     }
+    return false;
   }
-  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."
-    };
+  if (pi === path5.length) return false;
+  if (seg === "*") {
+    return matchSegments(path5, pi + 1, pattern, qi + 1);
   }
-  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.`
-    };
+  if (path5[pi] === seg) {
+    return matchSegments(path5, pi + 1, pattern, qi + 1);
   }
-  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.`
-  };
+  return false;
 }
 
-// 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);
+// src/registry.ts
+function tripleKey(aType, axbType, bType) {
+  return `${aType}:${axbType}:${bType}`;
 }
-function serializeFirestoreTypes(data) {
-  return serializeValue(data);
+function tripleKeyFor(e) {
+  return tripleKey(e.aType, e.axbType, e.bType);
 }
-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);
+function createRegistry(input) {
+  const map2 = /* @__PURE__ */ new Map();
+  let entries;
+  if (Array.isArray(input)) {
+    entries = input;
+  } else {
+    entries = discoveryToEntries(input);
   }
-  const result = {};
-  for (const key of Object.keys(value)) {
-    result[key] = serializeValue(value[key]);
+  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;
+    map2.set(key, { entry, validate: validator });
   }
-  return result;
-}
-function deserializeFirestoreTypes(data, db2) {
-  return deserializeValue(data, db2);
-}
-function deserializeValue(value, db2) {
-  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;
+  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]);
+    }
   }
-  if (Array.isArray(value)) {
-    return value.map((v) => deserializeValue(v, db2));
+  for (const [key, arr] of axbBuild) {
+    axbIndex.set(key, Object.freeze(arr));
   }
-  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 (db2) {
-          return db2.doc(obj.path);
+  return {
+    lookup(aType, axbType, bType) {
+      return map2.get(tripleKey(aType, axbType, bType))?.entry;
+    },
+    lookupByAxbType(axbType) {
+      return axbIndex.get(axbType) ?? [];
+    },
+    validate(aType, axbType, bType, data, scopePath) {
+      const rec = map2.get(tripleKey(aType, axbType, bType));
+      if (!rec) {
+        throw new RegistryViolationError(aType, axbType, bType);
+      }
+      if (scopePath !== void 0 && rec.entry.allowedIn && rec.entry.allowedIn.length > 0) {
+        if (!matchScopeAny(scopePath, rec.entry.allowedIn)) {
+          throw new RegistryScopeError(aType, axbType, bType, scopePath, rec.entry.allowedIn);
         }
-        if (!_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."
+      }
+      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
           );
         }
-        return obj;
-      default:
-        return obj;
+      }
+    },
+    entries() {
+      return entryList;
     }
-  }
-  const result = {};
-  for (const key of Object.keys(obj)) {
-    result[key] = deserializeValue(obj[key], db2);
-  }
-  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 version2 = currentVersion;
-  for (const step of sorted) {
-    if (step.fromVersion === version2) {
-      try {
-        result = await step.up(result);
-      } catch (err) {
-        if (err instanceof MigrationError) throw err;
-        throw new MigrationError(
-          `Migration from v${step.fromVersion} to v${step.toVersion} failed: ${err.message}`
-        );
+function createMergedRegistry(base, extension) {
+  const baseKeys = new Set(base.entries().map(tripleKeyFor));
+  return {
+    lookup(aType, axbType, bType) {
+      return base.lookup(aType, axbType, bType) ?? extension.lookup(aType, axbType, bType);
+    },
+    lookupByAxbType(axbType) {
+      const baseResults = base.lookupByAxbType(axbType);
+      const extResults = extension.lookupByAxbType(axbType);
+      if (extResults.length === 0) return baseResults;
+      if (baseResults.length === 0) return extResults;
+      const seen = new Set(baseResults.map(tripleKeyFor));
+      const merged = [...baseResults];
+      for (const entry of extResults) {
+        if (!seen.has(tripleKeyFor(entry))) {
+          merged.push(entry);
+        }
       }
-      if (!result || typeof result !== "object") {
-        throw new MigrationError(
-          `Migration from v${step.fromVersion} to v${step.toVersion} returned invalid data (expected object)`
-        );
+      return Object.freeze(merged);
+    },
+    validate(aType, axbType, bType, data, scopePath) {
+      if (baseKeys.has(tripleKey(aType, axbType, bType))) {
+        return base.validate(aType, axbType, bType, data, scopePath);
       }
-      version2 = step.toVersion;
-    }
-  }
-  if (version2 !== targetVersion) {
-    throw new MigrationError(
-      `Incomplete migration chain: reached v${version2} but target is v${targetVersion}`
-    );
-  }
-  return result;
+      return extension.validate(aType, axbType, bType, data, scopePath);
+    },
+    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);
+    }
+  };
 }
-function validateMigrationChain(migrations, label) {
-  if (migrations.length === 0) return;
-  const seen = /* @__PURE__ */ new Set();
-  for (const step of migrations) {
-    if (step.toVersion <= step.fromVersion) {
-      throw new MigrationError(
-        `${label}: migration step has toVersion (${step.toVersion}) <= fromVersion (${step.fromVersion})`
+function 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 "/")`
       );
     }
-    if (seen.has(step.fromVersion)) {
-      throw new MigrationError(
-        `${label}: duplicate migration step for fromVersion ${step.fromVersion}`
-      );
+    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 { createHash as createHash2 } from "node: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");
+var _WorkerCtor = null;
+async function loadWorkerCtor() {
+  if (_WorkerCtor) return _WorkerCtor;
+  const wt = await import("node:worker_threads");
+  _WorkerCtor = wt.Worker;
+  return _WorkerCtor;
+}
+async function ensureWorker() {
+  if (_worker) return _worker;
+  const Ctor = await loadWorkerCtor();
+  _worker = new Ctor(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;
+}
+async function sendToWorker(msg) {
+  const worker = await 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;
+}
+function hashSource(source) {
+  return createHash2("sha256").update(source).digest("hex");
+}
+var _serializationModule = null;
+async function loadSerialization() {
+  if (_serializationModule) return _serializationModule;
+  _serializationModule = await Promise.resolve().then(() => (init_serialization(), serialization_exports));
+  return _serializationModule;
+}
+function defaultExecutor(source) {
+  return async (data) => {
+    const { serializeFirestoreTypes: serializeFirestoreTypes2, deserializeFirestoreTypes: deserializeFirestoreTypes2 } = await loadSerialization();
+    const jsonData = JSON.stringify(serializeFirestoreTypes2(data));
+    const response = await sendToWorker({ type: "execute", source, jsonData });
+    if (response.jsonResult === void 0 || response.jsonResult === null) {
+      throw new MigrationError("Migration returned a non-JSON-serializable value");
+    }
+    try {
+      return deserializeFirestoreTypes2(JSON.parse(response.jsonResult));
+    } catch {
+      throw new MigrationError("Migration returned a non-JSON-serializable value");
+    }
+  };
+}
+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}`);
+    }
+    return;
+  }
+  await sendToWorker({ type: "compile", source });
+}
+function compileMigrationFn(source, executor = defaultExecutor) {
+  const cache = getExecutorCache(executor);
+  const key = hashSource(source);
+  const cached2 = cache.get(key);
+  if (cached2) return cached2;
+  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}`);
+  }
+}
+function compileMigrations(stored, executor) {
+  return stored.map((step) => ({
+    fromVersion: step.fromVersion,
+    toVersion: step.toVersion,
+    up: compileMigrationFn(step.up, executor)
+  }));
+}
+
+// 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 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"
+  }
+];
+function createBootstrapRegistry() {
+  return createRegistry([...BOOTSTRAP_ENTRIES]);
+}
+function generateDeterministicUid(metaType, name) {
+  const hash2 = createHash3("sha256").update(`${metaType}:${name}`).digest("base64url");
+  return hash2.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 record2 of nodeTypes) {
+    const data = record2.data;
+    if (data.migrations) {
+      for (const m of data.migrations) {
+        prevalidations.push(precompileSource(m.up, executor));
+      }
+    }
+  }
+  for (const record2 of edgeTypes) {
+    const data = record2.data;
+    if (data.migrations) {
+      for (const m of data.migrations) {
+        prevalidations.push(precompileSource(m.up, executor));
+      }
+    }
+  }
+  await Promise.all(prevalidations);
+  for (const record2 of nodeTypes) {
+    const data = record2.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
+    });
+  }
+  for (const record2 of edgeTypes) {
+    const data = record2.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
+        });
+      }
+    }
+  }
+  return createRegistry(entries);
+}
+
+// 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 });
+    }
+  }
+  if (filters.length === 0) {
+    throw new InvalidQueryError("findEdges requires at least one filter parameter");
+  }
+  const effectiveLimit = limit === void 0 ? DEFAULT_QUERY_LIMIT : limit || void 0;
+  return { strategy: "query", filters, options: { limit: effectiveLimit, orderBy } };
+}
+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 });
+    }
+  }
+  const effectiveLimit = limit === void 0 ? DEFAULT_QUERY_LIMIT : limit || void 0;
+  return { strategy: "query", filters, options: { limit: effectiveLimit, orderBy } };
+}
+
+// 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;
     }
-    seen.add(step.fromVersion);
   }
-  const sorted = [...migrations].sort((a, b) => a.fromVersion - b.fromVersion);
-  const targetVersion = Math.max(...migrations.map((m) => m.toVersion));
-  let version2 = 0;
-  for (const step of sorted) {
-    if (step.fromVersion === version2) {
-      version2 = step.toVersion;
-    } else if (step.fromVersion > version2) {
-      throw new MigrationError(
-        `${label}: migration chain has a gap \u2014 no step covers v${version2} \u2192 v${step.fromVersion}`
-      );
+  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 };
     }
   }
-  if (version2 !== targetVersion) {
-    throw new MigrationError(
-      `${label}: migration chain does not reach v${targetVersion} (stuck at v${version2})`
-    );
-  }
-}
-async function migrateRecord(record2, registry2, globalWriteBack = "off") {
-  const entry = registry2.lookup(record2.aType, record2.axbType, record2.bType);
-  if (!entry?.migrations?.length || !entry.schemaVersion) {
-    return { record: record2, migrated: false, writeBack: "off" };
+  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 currentVersion = record2.v ?? 0;
-  if (currentVersion >= entry.schemaVersion) {
-    return { record: record2, migrated: false, writeBack: "off" };
+  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 migratedData = await applyMigrationChain(
-    record2.data,
-    currentVersion,
-    entry.schemaVersion,
-    entry.migrations
-  );
-  const writeBack = entry.migrationWriteBack ?? globalWriteBack ?? "off";
   return {
-    record: { ...record2, data: migratedData, v: entry.schemaVersion },
-    migrated: true,
-    writeBack
+    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.`
   };
 }
-async function migrateRecords(records, registry2, globalWriteBack = "off") {
-  return Promise.all(
-    records.map((r) => migrateRecord(r, registry2, globalWriteBack))
-  );
-}
 
 // src/transaction.ts
+function buildWritableNodeRecord2(aType, uid, data) {
+  return { aType, aUid: uid, axbType: NODE_RELATION, bType: aType, bUid: uid, data };
+}
+function buildWritableEdgeRecord2(aType, aUid, axbType, bType, bUid, data) {
+  return { aType, aUid, axbType, bType, bUid, data };
+}
 var GraphTransactionImpl = class {
-  constructor(adapter, registry2, scanProtection = "error", scopePath = "", globalWriteBack = "off", db2) {
-    this.adapter = adapter;
+  constructor(backend, registry2, scanProtection = "error", scopePath = "", globalWriteBack = "off") {
+    this.backend = backend;
     this.registry = registry2;
     this.scanProtection = scanProtection;
     this.scopePath = scopePath;
     this.globalWriteBack = globalWriteBack;
-    this.db = db2;
   }
   async getNode(uid) {
     const docId = computeNodeDocId(uid);
-    const record2 = await this.adapter.getDoc(docId);
+    const record2 = await this.backend.getDoc(docId);
     if (!record2 || !this.registry) return record2;
     const result = await migrateRecord(record2, 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);
+      await this.backend.updateDoc(docId, {
+        replaceData: result.record.data,
+        v: result.record.v
+      });
     }
     return result.record;
   }
   async getEdge(aUid, axbType, bUid) {
     const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record2 = await this.adapter.getDoc(docId);
+    const record2 = await this.backend.getDoc(docId);
     if (!record2 || !this.registry) return record2;
     const result = await migrateRecord(record2, 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);
+      await this.backend.updateDoc(docId, {
+        replaceData: result.record.data,
+        v: result.record.v
+      });
     }
     return result.record;
   }
   async edgeExists(aUid, axbType, bUid) {
     const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record2 = await this.adapter.getDoc(docId);
+    const record2 = await this.backend.getDoc(docId);
     return record2 !== null;
   }
   checkQuerySafety(filters, allowCollectionScan) {
@@ -30254,11 +30827,235 @@ var GraphTransactionImpl = class {
     const plan = buildEdgeQueryPlan(params);
     let records;
     if (plan.strategy === "get") {
-      const record2 = await this.adapter.getDoc(plan.docId);
+      const record2 = await this.backend.getDoc(plan.docId);
+      records = record2 ? [record2] : [];
+    } else {
+      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
+      records = await this.backend.query(plan.filters, plan.options);
+    }
+    return this.applyMigrations(records);
+  }
+  async findNodes(params) {
+    const plan = buildNodeQueryPlan(params);
+    let records;
+    if (plan.strategy === "get") {
+      const record2 = await this.backend.getDoc(plan.docId);
+      records = record2 ? [record2] : [];
+    } else {
+      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
+      records = await this.backend.query(plan.filters, plan.options);
+    }
+    return this.applyMigrations(records);
+  }
+  async applyMigrations(records) {
+    if (!this.registry || records.length === 0) return records;
+    const results = await migrateRecords(records, this.registry, this.globalWriteBack);
+    for (const result of results) {
+      if (result.migrated && result.writeBack !== "off") {
+        const docId = result.record.axbType === NODE_RELATION ? computeNodeDocId(result.record.aUid) : computeEdgeDocId(result.record.aUid, result.record.axbType, result.record.bUid);
+        await this.backend.updateDoc(docId, {
+          replaceData: result.record.data,
+          v: result.record.v
+        });
+      }
+    }
+    return results.map((r) => r.record);
+  }
+  async putNode(aType, uid, data) {
+    if (this.registry) {
+      this.registry.validate(aType, NODE_RELATION, aType, data, this.scopePath);
+    }
+    const docId = computeNodeDocId(uid);
+    const record2 = buildWritableNodeRecord2(aType, uid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record2.v = entry.schemaVersion;
+      }
+    }
+    await this.backend.setDoc(docId, record2);
+  }
+  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 record2 = buildWritableEdgeRecord2(aType, aUid, axbType, bType, bUid, data);
+    if (this.registry) {
+      const entry = this.registry.lookup(aType, axbType, bType);
+      if (entry?.schemaVersion && entry.schemaVersion > 0) {
+        record2.v = entry.schemaVersion;
+      }
+    }
+    await this.backend.setDoc(docId, record2);
+  }
+  async updateNode(uid, data) {
+    const docId = computeNodeDocId(uid);
+    await this.backend.updateDoc(docId, { dataFields: data });
+  }
+  async removeNode(uid) {
+    const docId = computeNodeDocId(uid);
+    await this.backend.deleteDoc(docId);
+  }
+  async removeEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    await this.backend.deleteDoc(docId);
+  }
+};
+
+// src/client.ts
+var RESERVED_TYPE_NAMES = /* @__PURE__ */ new Set([META_NODE_TYPE, META_EDGE_TYPE]);
+function buildWritableNodeRecord3(aType, uid, data) {
+  return { aType, aUid: uid, axbType: NODE_RELATION, bType: aType, bUid: uid, data };
+}
+function buildWritableEdgeRecord3(aType, aUid, axbType, bType, bUid, data) {
+  return { aType, aUid, axbType, bType, bUid, data };
+}
+var GraphClientImpl = class _GraphClientImpl {
+  constructor(backend, options, metaBackend) {
+    this.backend = backend;
+    this.globalWriteBack = options?.migrationWriteBack ?? "off";
+    this.migrationSandbox = options?.migrationSandbox;
+    if (options?.registryMode) {
+      this.dynamicConfig = options.registryMode;
+      this.bootstrapRegistry = createBootstrapRegistry();
+      if (options.registry) {
+        this.staticRegistry = options.registry;
+      }
+      this.metaBackend = metaBackend;
+    } else {
+      this.staticRegistry = options?.registry;
+    }
+    this.scanProtection = options?.scanProtection ?? "error";
+  }
+  scanProtection;
+  // Static mode
+  staticRegistry;
+  // Dynamic mode
+  dynamicConfig;
+  bootstrapRegistry;
+  dynamicRegistry;
+  metaBackend;
+  // Migration settings
+  globalWriteBack;
+  migrationSandbox;
+  // ---------------------------------------------------------------------------
+  // Backend access (exposed for traversal helpers and subgraph cloning)
+  // ---------------------------------------------------------------------------
+  /** @internal */
+  getBackend() {
+    return this.backend;
+  }
+  // ---------------------------------------------------------------------------
+  // Registry routing
+  // ---------------------------------------------------------------------------
+  getRegistryForType(aType) {
+    if (!this.dynamicConfig) return this.staticRegistry;
+    if (aType === META_NODE_TYPE || aType === META_EDGE_TYPE) {
+      return this.bootstrapRegistry;
+    }
+    return this.dynamicRegistry ?? this.staticRegistry ?? this.bootstrapRegistry;
+  }
+  getBackendForType(aType) {
+    if (this.metaBackend && (aType === META_NODE_TYPE || aType === META_EDGE_TYPE)) {
+      return this.metaBackend;
+    }
+    return this.backend;
+  }
+  getCombinedRegistry() {
+    if (!this.dynamicConfig) return this.staticRegistry;
+    return this.dynamicRegistry ?? this.staticRegistry ?? this.bootstrapRegistry;
+  }
+  // ---------------------------------------------------------------------------
+  // Query safety
+  // ---------------------------------------------------------------------------
+  checkQuerySafety(filters, allowCollectionScan) {
+    if (allowCollectionScan || this.scanProtection === "off") return;
+    const result = analyzeQuerySafety(filters);
+    if (result.safe) return;
+    if (this.scanProtection === "error") {
+      throw new QuerySafetyError(result.reason);
+    }
+    console.warn(`[firegraph] Query safety warning: ${result.reason}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Migration helpers
+  // ---------------------------------------------------------------------------
+  async applyMigration(record2, docId) {
+    const registry2 = this.getCombinedRegistry();
+    if (!registry2) return record2;
+    const result = await migrateRecord(record2, registry2, this.globalWriteBack);
+    if (result.migrated) {
+      this.handleWriteBack(result, docId);
+    }
+    return result.record;
+  }
+  async applyMigrations(records) {
+    const registry2 = this.getCombinedRegistry();
+    if (!registry2 || records.length === 0) return records;
+    const results = await migrateRecords(records, registry2, this.globalWriteBack);
+    for (const result of results) {
+      if (result.migrated) {
+        const docId = result.record.axbType === NODE_RELATION ? computeNodeDocId(result.record.aUid) : computeEdgeDocId(result.record.aUid, result.record.axbType, result.record.bUid);
+        this.handleWriteBack(result, docId);
+      }
+    }
+    return results.map((r) => r.record);
+  }
+  /**
+   * Fire-and-forget write-back for a migrated record. Both `'eager'` and
+   * `'background'` are non-blocking; the difference is the log level on
+   * failure. For synchronous write-back, use a transaction — see
+   * `GraphTransactionImpl`.
+   */
+  handleWriteBack(result, docId) {
+    if (result.writeBack === "off") return;
+    const doWriteBack = async () => {
+      try {
+        await this.backend.updateDoc(docId, {
+          replaceData: result.record.data,
+          v: result.record.v
+        });
+      } catch (err) {
+        const msg = `[firegraph] Migration write-back failed for ${docId}: ${err.message}`;
+        if (result.writeBack === "eager") {
+          console.error(msg);
+        } else {
+          console.warn(msg);
+        }
+      }
+    };
+    void doWriteBack();
+  }
+  // ---------------------------------------------------------------------------
+  // GraphReader
+  // ---------------------------------------------------------------------------
+  async getNode(uid) {
+    const docId = computeNodeDocId(uid);
+    const record2 = await this.backend.getDoc(docId);
+    if (!record2) return null;
+    return this.applyMigration(record2, docId);
+  }
+  async getEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record2 = await this.backend.getDoc(docId);
+    if (!record2) return null;
+    return this.applyMigration(record2, docId);
+  }
+  async edgeExists(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record2 = await this.backend.getDoc(docId);
+    return record2 !== null;
+  }
+  async findEdges(params) {
+    const plan = buildEdgeQueryPlan(params);
+    let records;
+    if (plan.strategy === "get") {
+      const record2 = await this.backend.getDoc(plan.docId);
       records = record2 ? [record2] : [];
     } else {
       this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.adapter.query(plan.filters, plan.options);
+      records = await this.backend.query(plan.filters, plan.options);
     }
     return this.applyMigrations(records);
   }
@@ -30266,1309 +31063,916 @@ var GraphTransactionImpl = class {
     const plan = buildNodeQueryPlan(params);
     let records;
     if (plan.strategy === "get") {
-      const record2 = await this.adapter.getDoc(plan.docId);
+      const record2 = await this.backend.getDoc(plan.docId);
       records = record2 ? [record2] : [];
     } else {
       this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.adapter.query(plan.filters, plan.options);
+      records = await this.backend.query(plan.filters, plan.options);
     }
     return this.applyMigrations(records);
   }
-  async applyMigrations(records) {
-    if (!this.registry || records.length === 0) return records;
-    const results = await migrateRecords(records, this.registry, this.globalWriteBack);
-    for (const result of results) {
-      if (result.migrated && result.writeBack !== "off") {
-        const docId = result.record.axbType === NODE_RELATION ? computeNodeDocId(result.record.aUid) : computeEdgeDocId(result.record.aUid, result.record.axbType, result.record.bUid);
-        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 record2 = buildNodeRecord(aType, uid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record2.v = entry.schemaVersion;
-      }
-    }
-    this.adapter.setDoc(docId, record2);
-  }
-  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 record2 = buildEdgeRecord(aType, aUid, axbType, bType, bUid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, axbType, bType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record2.v = entry.schemaVersion;
-      }
-    }
-    this.adapter.setDoc(docId, record2);
-  }
-  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, registry2, scopePath = "") {
-    this.adapter = adapter;
-    this.registry = registry2;
-    this.scopePath = scopePath;
-  }
+  // ---------------------------------------------------------------------------
+  // GraphWriter
+  // ---------------------------------------------------------------------------
   async putNode(aType, uid, data) {
-    if (this.registry) {
-      this.registry.validate(aType, NODE_RELATION, aType, data, this.scopePath);
+    const registry2 = this.getRegistryForType(aType);
+    if (registry2) {
+      registry2.validate(aType, NODE_RELATION, aType, data, this.backend.scopePath);
     }
+    const backend = this.getBackendForType(aType);
     const docId = computeNodeDocId(uid);
-    const record2 = buildNodeRecord(aType, uid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, NODE_RELATION, aType);
+    const record2 = buildWritableNodeRecord3(aType, uid, data);
+    if (registry2) {
+      const entry = registry2.lookup(aType, NODE_RELATION, aType);
       if (entry?.schemaVersion && entry.schemaVersion > 0) {
         record2.v = entry.schemaVersion;
       }
     }
-    this.adapter.setDoc(docId, record2);
+    await backend.setDoc(docId, record2);
   }
   async putEdge(aType, aUid, axbType, bType, bUid, data) {
-    if (this.registry) {
-      this.registry.validate(aType, axbType, bType, data, this.scopePath);
+    const registry2 = this.getRegistryForType(aType);
+    if (registry2) {
+      registry2.validate(aType, axbType, bType, data, this.backend.scopePath);
     }
+    const backend = this.getBackendForType(aType);
     const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record2 = buildEdgeRecord(aType, aUid, axbType, bType, bUid, data);
-    if (this.registry) {
-      const entry = this.registry.lookup(aType, axbType, bType);
+    const record2 = buildWritableEdgeRecord3(aType, aUid, axbType, bType, bUid, data);
+    if (registry2) {
+      const entry = registry2.lookup(aType, axbType, bType);
       if (entry?.schemaVersion && entry.schemaVersion > 0) {
         record2.v = entry.schemaVersion;
       }
     }
-    this.adapter.setDoc(docId, record2);
+    await backend.setDoc(docId, record2);
   }
   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);
+    await this.backend.updateDoc(docId, { dataFields: data });
   }
   async removeNode(uid) {
     const docId = computeNodeDocId(uid);
-    this.adapter.deleteDoc(docId);
+    await this.backend.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(db2, 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 = db2.batch();
-        const collectionRef = db2.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 (committed) {
-      completedBatches++;
-    }
-    if (onProgress) {
-      onProgress({
-        completedBatches,
-        totalBatches: chunks.length,
-        deletedSoFar: deleted
-      });
-    }
-  }
-  return { deleted, batches: completedBatches, errors };
-}
-async function bulkRemoveEdges(db2, collectionPath, reader, params, options) {
-  const effectiveParams = params.limit !== void 0 ? { ...params, allowCollectionScan: params.allowCollectionScan ?? true } : { ...params, limit: 0, allowCollectionScan: params.allowCollectionScan ?? true };
-  const edges = await reader.findEdges(effectiveParams);
-  const docIds = edges.map((e) => computeEdgeDocId(e.aUid, e.axbType, e.bUid));
-  return bulkDeleteDocIds(db2, collectionPath, docIds, options);
-}
-async function deleteSubcollectionsRecursive(db2, collectionPath, docId, options) {
-  const docRef = db2.collection(collectionPath).doc(docId);
-  const subcollections = await docRef.listCollections();
-  if (subcollections.length === 0) return { deleted: 0, errors: [] };
-  let totalDeleted = 0;
-  const allErrors = [];
-  const subOptions = options ? { batchSize: options.batchSize, maxRetries: options.maxRetries } : void 0;
-  for (const subCollRef of subcollections) {
-    const subCollPath = subCollRef.path;
-    const snapshot = await subCollRef.select().get();
-    const subDocIds = snapshot.docs.map((d) => d.id);
-    for (const subDocId of subDocIds) {
-      const subResult = await deleteSubcollectionsRecursive(db2, subCollPath, subDocId, subOptions);
-      totalDeleted += subResult.deleted;
-      allErrors.push(...subResult.errors);
-    }
-    if (subDocIds.length > 0) {
-      const result = await bulkDeleteDocIds(db2, subCollPath, subDocIds, subOptions);
-      totalDeleted += result.deleted;
-      allErrors.push(...result.errors);
-    }
+    await this.backend.deleteDoc(docId);
   }
-  return { deleted: totalDeleted, errors: allErrors };
-}
-async function removeNodeCascade(db2, collectionPath, reader, uid, options) {
-  const [outgoingRaw, incomingRaw] = await Promise.all([
-    reader.findEdges({ aUid: uid, allowCollectionScan: true, limit: 0 }),
-    reader.findEdges({ bUid: uid, allowCollectionScan: true, limit: 0 })
-  ]);
-  const outgoing = outgoingRaw.filter((e) => e.axbType !== NODE_RELATION);
-  const incoming = incomingRaw.filter((e) => e.axbType !== NODE_RELATION);
-  const edgeDocIdSet = /* @__PURE__ */ new Set();
-  const allEdges = [];
-  for (const edge of [...outgoing, ...incoming]) {
-    const docId = computeEdgeDocId(edge.aUid, edge.axbType, edge.bUid);
-    if (!edgeDocIdSet.has(docId)) {
-      edgeDocIdSet.add(docId);
-      allEdges.push(edge);
-    }
+  // ---------------------------------------------------------------------------
+  // Transactions & Batches
+  // ---------------------------------------------------------------------------
+  async runTransaction(fn) {
+    return this.backend.runTransaction(async (txBackend) => {
+      const graphTx = new GraphTransactionImpl(
+        txBackend,
+        this.getCombinedRegistry(),
+        this.scanProtection,
+        this.backend.scopePath,
+        this.globalWriteBack
+      );
+      return fn(graphTx);
+    });
   }
-  const shouldDeleteSubcollections = options?.deleteSubcollections !== false;
-  const nodeDocId = computeNodeDocId(uid);
-  let subcollectionResult = { deleted: 0, errors: [] };
-  if (shouldDeleteSubcollections) {
-    subcollectionResult = await deleteSubcollectionsRecursive(
-      db2,
-      collectionPath,
-      nodeDocId,
-      options
+  batch() {
+    return new GraphBatchImpl(
+      this.backend.createBatch(),
+      this.getCombinedRegistry(),
+      this.backend.scopePath
     );
   }
-  const edgeDocIds = allEdges.map((e) => computeEdgeDocId(e.aUid, e.axbType, e.bUid));
-  const allDocIds = [...edgeDocIds, nodeDocId];
-  const batchSize = Math.min(options?.batchSize ?? MAX_BATCH_SIZE, MAX_BATCH_SIZE);
-  const result = await bulkDeleteDocIds(db2, collectionPath, allDocIds, {
-    ...options,
-    batchSize
-  });
-  const totalChunks = Math.ceil(allDocIds.length / batchSize);
-  const nodeChunkIndex = totalChunks - 1;
-  const nodeDeleted = !result.errors.some((e) => e.batchIndex === nodeChunkIndex);
-  const topLevelEdgesDeleted = nodeDeleted ? result.deleted - 1 : result.deleted;
-  return {
-    deleted: result.deleted + subcollectionResult.deleted,
-    batches: result.batches,
-    errors: [...result.errors, ...subcollectionResult.errors],
-    edgesDeleted: topLevelEdgesDeleted,
-    nodeDeleted
-  };
-}
-
-// src/dynamic-registry.ts
-import { createHash as createHash3 } from "node:crypto";
-
-// src/json-schema.ts
-var import_ajv = __toESM(require_ajv(), 1);
-var import_ajv_formats = __toESM(require_dist(), 1);
-var ajv = new import_ajv.default({ allErrors: true, strict: false });
-(0, import_ajv_formats.default)(ajv);
-function compileSchema(schema, label) {
-  const validate = ajv.compile(schema);
-  return (data) => {
-    if (!validate(data)) {
-      const errors = validate.errors ?? [];
-      const messages = errors.map((err) => `${err.instancePath || "/"}${err.message ? ": " + err.message : ""}`).join("; ");
-      throw new ValidationError(
-        `Data validation failed${label ? " for " + label : ""}: ${messages}`,
-        errors
+  // ---------------------------------------------------------------------------
+  // 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"
       );
     }
-  };
-}
-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, required2) {
-  if (!prop) return { name, type: "unknown", required: required2 };
-  if (Array.isArray(prop.enum)) {
-    return {
-      name,
-      type: "enum",
-      required: required2,
-      enumValues: prop.enum,
-      description: prop.description
-    };
+    if (name.includes("/")) {
+      throw new FiregraphError(
+        `Subgraph name must not contain "/": got "${name}". Use chained .subgraph() calls for nested subgraphs.`,
+        "INVALID_SUBGRAPH"
+      );
+    }
+    const childBackend = this.backend.subgraph(parentNodeUid, name);
+    return new _GraphClientImpl(
+      childBackend,
+      {
+        registry: this.getCombinedRegistry(),
+        scanProtection: this.scanProtection,
+        migrationWriteBack: this.globalWriteBack,
+        migrationSandbox: this.migrationSandbox
+      }
+      // Subgraphs do not have meta-backends; meta lives only at the root.
+    );
   }
-  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);
+  // ---------------------------------------------------------------------------
+  // Collection group query
+  // ---------------------------------------------------------------------------
+  async findEdgesGlobal(params, collectionName) {
+    if (!this.backend.findEdgesGlobal) {
+      throw new FiregraphError(
+        "findEdgesGlobal() is not supported by the current storage backend.",
+        "UNSUPPORTED_OPERATION"
+      );
     }
-    return { name, type: "unknown", required: required2, description: prop.description };
+    const plan = buildEdgeQueryPlan(params);
+    if (plan.strategy === "get") {
+      throw new FiregraphError(
+        "findEdgesGlobal() requires a query, not a direct document lookup. Omit one of aUid/axbType/bUid to force a query strategy.",
+        "INVALID_QUERY"
+      );
+    }
+    this.checkQuerySafety(plan.filters, params.allowCollectionScan);
+    const records = await this.backend.findEdgesGlobal(params, collectionName);
+    return this.applyMigrations(records);
   }
-  const type = prop.type;
-  if (type === "string") {
-    return {
-      name,
-      type: "string",
-      required: required2,
-      minLength: prop.minLength,
-      maxLength: prop.maxLength,
-      pattern: prop.pattern,
-      description: prop.description
-    };
+  // ---------------------------------------------------------------------------
+  // Bulk operations
+  // ---------------------------------------------------------------------------
+  async removeNodeCascade(uid, options) {
+    return this.backend.removeNodeCascade(uid, this, options);
   }
-  if (type === "number" || type === "integer") {
-    return {
-      name,
-      type: "number",
-      required: required2,
-      min: prop.minimum,
-      max: prop.maximum,
-      isInt: type === "integer" ? true : void 0,
-      description: prop.description
-    };
+  async bulkRemoveEdges(params, options) {
+    return this.backend.bulkRemoveEdges(params, this, options);
   }
-  if (type === "boolean") {
-    return { name, type: "boolean", required: required2, description: prop.description };
+  // ---------------------------------------------------------------------------
+  // 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);
   }
-  if (type === "array") {
-    const itemMeta = prop.items ? propertyToFieldMeta("item", prop.items, true) : void 0;
-    return {
+  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,
-      type: "array",
-      required: required2,
-      itemMeta,
-      description: prop.description
+      from: topology.from,
+      to: topology.to
     };
+    if (jsonSchema !== void 0) data.jsonSchema = jsonSchema;
+    if (topology.inverseLabel !== void 0) data.inverseLabel = topology.inverseLabel;
+    if (topology.targetGraph !== void 0) data.targetGraph = topology.targetGraph;
+    if (description !== void 0) data.description = description;
+    if (options?.titleField !== void 0) data.titleField = options.titleField;
+    if (options?.subtitleField !== void 0) data.subtitleField = options.subtitleField;
+    if (options?.viewTemplate !== void 0) data.viewTemplate = options.viewTemplate;
+    if (options?.viewCss !== void 0) data.viewCss = options.viewCss;
+    if (options?.allowedIn !== void 0) data.allowedIn = options.allowedIn;
+    if (options?.migrationWriteBack !== void 0)
+      data.migrationWriteBack = options.migrationWriteBack;
+    if (options?.migrations !== void 0) {
+      data.migrations = await this.serializeMigrations(options.migrations);
+    }
+    await this.putNode(META_EDGE_TYPE, uid, data);
   }
-  if (type === "object") {
+  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;
+    }
+  }
+  async serializeMigrations(migrations) {
+    const result = migrations.map((m) => {
+      const source = typeof m.up === "function" ? m.up.toString() : m.up;
+      return { fromVersion: m.fromVersion, toVersion: m.toVersion, up: source };
+    });
+    await Promise.all(result.map((m) => precompileSource(m.up, this.migrationSandbox)));
+    return result;
+  }
+  /**
+   * Build a `GraphReader` over the meta-backend. If meta lives in the same
+   * collection as the main backend, `this` is returned directly.
+   */
+  createMetaReader() {
+    if (!this.metaBackend) return this;
+    const backend = this.metaBackend;
+    const executeMetaQuery = (filters, options) => backend.query(filters, options);
     return {
-      name,
-      type: "object",
-      required: required2,
-      fields: jsonSchemaToFieldMeta(prop),
-      description: prop.description
+      async getNode(uid) {
+        return backend.getDoc(computeNodeDocId(uid));
+      },
+      async getEdge(aUid, axbType, bUid) {
+        return backend.getDoc(computeEdgeDocId(aUid, axbType, bUid));
+      },
+      async edgeExists(aUid, axbType, bUid) {
+        const record2 = await backend.getDoc(computeEdgeDocId(aUid, axbType, bUid));
+        return record2 !== null;
+      },
+      async findEdges(params) {
+        const plan = buildEdgeQueryPlan(params);
+        if (plan.strategy === "get") {
+          const record2 = await backend.getDoc(plan.docId);
+          return record2 ? [record2] : [];
+        }
+        return executeMetaQuery(plan.filters, plan.options);
+      },
+      async findNodes(params) {
+        const plan = buildNodeQueryPlan(params);
+        if (plan.strategy === "get") {
+          const record2 = await backend.getDoc(plan.docId);
+          return record2 ? [record2] : [];
+        }
+        return executeMetaQuery(plan.filters, plan.options);
+      }
     };
   }
-  return { name, type: "unknown", required: required2, 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(path5, pi, pattern, qi) {
-  if (pi === path5.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 <= path5.length - pi; skip++) {
-      if (matchSegments(path5, pi + skip, pattern, qi + 1)) return true;
-    }
-    return false;
-  }
-  if (pi === path5.length) return false;
-  if (seg === "*") {
-    return matchSegments(path5, pi + 1, pattern, qi + 1);
+// src/discover.ts
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+var DiscoveryError = class extends FiregraphError {
+  constructor(message) {
+    super(message, "DISCOVERY_ERROR");
+    this.name = "DiscoveryError";
   }
-  if (path5[pi] === seg) {
-    return matchSegments(path5, pi + 1, pattern, qi + 1);
+};
+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);
   }
-  return false;
 }
-
-// src/registry.ts
-function tripleKey(aType, axbType, bType) {
-  return `${aType}:${axbType}:${bType}`;
+function readJsonIfExists(filePath) {
+  if (!existsSync(filePath)) return void 0;
+  return readJson(filePath);
 }
-function tripleKeyFor(e) {
-  return tripleKey(e.aType, e.axbType, e.bType);
+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.`
+  );
 }
-function createRegistry(input) {
-  const map2 = /* @__PURE__ */ new Map();
-  let entries;
-  if (Array.isArray(input)) {
-    entries = input;
-  } else {
-    entries = discoveryToEntries(input);
+var _jiti;
+function getJiti() {
+  if (!_jiti) {
+    const base = typeof __filename !== "undefined" ? __filename : import.meta.url;
+    const esmRequire = createRequire(base);
+    const { createJiti: createJiti2 } = esmRequire("jiti");
+    _jiti = createJiti2(base, { interopDefault: true });
   }
-  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 "/")`
+  return _jiti;
+}
+function loadSchemaModule(filePath, entityLabel) {
+  try {
+    const jiti2 = getJiti();
+    const mod = jiti2(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.`
       );
     }
-    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;
-    map2.set(key, { entry, validate: validator });
+    return schema;
+  } catch (err) {
+    if (err instanceof DiscoveryError) throw err;
+    throw new DiscoveryError(
+      `Failed to load schema module ${filePath} for ${entityLabel}: ${err.message}`
+    );
   }
-  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]);
-    }
+}
+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;
   }
-  for (const [key, arr] of axbBuild) {
-    axbIndex.set(key, Object.freeze(arr));
+  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 {
-    lookup(aType, axbType, bType) {
-      return map2.get(tripleKey(aType, axbType, bType))?.entry;
-    },
-    lookupByAxbType(axbType) {
-      return axbIndex.get(axbType) ?? [];
-    },
-    validate(aType, axbType, bType, data, scopePath) {
-      const rec = map2.get(tripleKey(aType, axbType, bType));
-      if (!rec) {
-        throw new RegistryViolationError(aType, axbType, bType);
-      }
-      if (scopePath !== void 0 && rec.entry.allowedIn && rec.entry.allowedIn.length > 0) {
-        if (!matchScopeAny(scopePath, rec.entry.allowedIn)) {
-          throw new RegistryScopeError(aType, axbType, bType, scopePath, rec.entry.allowedIn);
-        }
-      }
-      if (rec.validate) {
-        try {
-          rec.validate(data);
-        } catch (err) {
-          if (err instanceof ValidationError) throw err;
-          throw new ValidationError(
-            `Data validation failed for (${aType}) -[${axbType}]-> (${bType})`,
-            err
-          );
-        }
-      }
-    },
-    entries() {
-      return entryList;
+  return void 0;
+}
+function loadMigrations(filePath, entityLabel) {
+  try {
+    const jiti2 = getJiti();
+    const mod = jiti2(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 createMergedRegistry(base, extension) {
-  const baseKeys = new Set(base.entries().map(tripleKeyFor));
+function loadNodeEntity(dir, name) {
+  const schema = loadSchema(dir, `node type "${name}"`);
+  const meta3 = 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 {
-    lookup(aType, axbType, bType) {
-      return base.lookup(aType, axbType, bType) ?? extension.lookup(aType, axbType, bType);
-    },
-    lookupByAxbType(axbType) {
-      const baseResults = base.lookupByAxbType(axbType);
-      const extResults = extension.lookupByAxbType(axbType);
-      if (extResults.length === 0) return baseResults;
-      if (baseResults.length === 0) return extResults;
-      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);
-    },
-    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);
-    },
-    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);
-    }
+    kind: "node",
+    name,
+    schema,
+    description: meta3?.description,
+    titleField: meta3?.titleField,
+    subtitleField: meta3?.subtitleField,
+    viewDefaults: meta3?.viewDefaults,
+    viewsPath,
+    sampleData,
+    allowedIn: meta3?.allowedIn,
+    migrations,
+    migrationWriteBack: meta3?.migrationWriteBack
   };
 }
-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
-    });
+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 meta3 = 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: meta3?.description,
+    titleField: meta3?.titleField,
+    subtitleField: meta3?.subtitleField,
+    viewDefaults: meta3?.viewDefaults,
+    viewsPath,
+    sampleData,
+    allowedIn: meta3?.allowedIn,
+    targetGraph: topology.targetGraph ?? meta3?.targetGraph,
+    migrations,
+    migrationWriteBack: meta3?.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}`);
   }
-  for (const [axbType, entity] of discovery.edges) {
+  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;
-    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
+    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 entries;
+  return {
+    result: { nodes, edges },
+    warnings
+  };
 }
 
-// src/sandbox.ts
-import { Worker } from "node:worker_threads";
-import { createHash as createHash2 } from "node: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 });
-  });
+// src/internal/firestore-backend.ts
+import { FieldValue as FieldValue2 } 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));
 }
-var compiledCache = /* @__PURE__ */ new WeakMap();
-function getExecutorCache(executor) {
-  let cache = compiledCache.get(executor);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    compiledCache.set(executor, cache);
+function chunk(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
   }
-  return cache;
-}
-function hashSource(source) {
-  return createHash2("sha256").update(source).digest("hex");
+  return chunks;
 }
-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");
+async function bulkDeleteDocIds(db2, 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 = db2.batch();
+        const collectionRef = db2.collection(collectionPath);
+        for (const id of ids) {
+          batch.delete(collectionRef.doc(id));
         }
-        try {
-          return deserializeFirestoreTypes(JSON.parse(response.jsonResult));
-        } catch {
-          throw new MigrationError("Migration returned a non-JSON-serializable value");
+        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 (committed) {
+      completedBatches++;
+    }
+    if (onProgress) {
+      onProgress({
+        completedBatches,
+        totalBatches: chunks.length,
+        deletedSoFar: deleted
+      });
+    }
+  }
+  return { deleted, batches: completedBatches, errors };
 }
-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}`
-      );
+async function bulkRemoveEdges(db2, collectionPath, reader, params, options) {
+  const effectiveParams = params.limit !== void 0 ? { ...params, allowCollectionScan: params.allowCollectionScan ?? true } : { ...params, limit: 0, allowCollectionScan: params.allowCollectionScan ?? true };
+  const edges = await reader.findEdges(effectiveParams);
+  const docIds = edges.map((e) => computeEdgeDocId(e.aUid, e.axbType, e.bUid));
+  return bulkDeleteDocIds(db2, collectionPath, docIds, options);
+}
+async function deleteSubcollectionsRecursive(db2, collectionPath, docId, options) {
+  const docRef = db2.collection(collectionPath).doc(docId);
+  const subcollections = await docRef.listCollections();
+  if (subcollections.length === 0) return { deleted: 0, errors: [] };
+  let totalDeleted = 0;
+  const allErrors = [];
+  const subOptions = options ? { batchSize: options.batchSize, maxRetries: options.maxRetries } : void 0;
+  for (const subCollRef of subcollections) {
+    const subCollPath = subCollRef.path;
+    const snapshot = await subCollRef.select().get();
+    const subDocIds = snapshot.docs.map((d) => d.id);
+    for (const subDocId of subDocIds) {
+      const subResult = await deleteSubcollectionsRecursive(db2, subCollPath, subDocId, subOptions);
+      totalDeleted += subResult.deleted;
+      allErrors.push(...subResult.errors);
+    }
+    if (subDocIds.length > 0) {
+      const result = await bulkDeleteDocIds(db2, subCollPath, subDocIds, subOptions);
+      totalDeleted += result.deleted;
+      allErrors.push(...result.errors);
     }
-    return;
   }
-  await sendToWorker({ type: "compile", source });
+  return { deleted: totalDeleted, errors: allErrors };
 }
-function compileMigrationFn(source, executor = defaultExecutor) {
-  const cache = getExecutorCache(executor);
-  const key = hashSource(source);
-  const cached2 = cache.get(key);
-  if (cached2) return cached2;
-  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}`
+async function removeNodeCascade(db2, collectionPath, reader, uid, options) {
+  const [outgoingRaw, incomingRaw] = await Promise.all([
+    reader.findEdges({ aUid: uid, allowCollectionScan: true, limit: 0 }),
+    reader.findEdges({ bUid: uid, allowCollectionScan: true, limit: 0 })
+  ]);
+  const outgoing = outgoingRaw.filter((e) => e.axbType !== NODE_RELATION);
+  const incoming = incomingRaw.filter((e) => e.axbType !== NODE_RELATION);
+  const edgeDocIdSet = /* @__PURE__ */ new Set();
+  const allEdges = [];
+  for (const edge of [...outgoing, ...incoming]) {
+    const docId = computeEdgeDocId(edge.aUid, edge.axbType, edge.bUid);
+    if (!edgeDocIdSet.has(docId)) {
+      edgeDocIdSet.add(docId);
+      allEdges.push(edge);
+    }
+  }
+  const shouldDeleteSubcollections = options?.deleteSubcollections !== false;
+  const nodeDocId = computeNodeDocId(uid);
+  let subcollectionResult = { deleted: 0, errors: [] };
+  if (shouldDeleteSubcollections) {
+    subcollectionResult = await deleteSubcollectionsRecursive(
+      db2,
+      collectionPath,
+      nodeDocId,
+      options
     );
   }
-}
-function compileMigrations(stored, executor) {
-  return stored.map((step) => ({
-    fromVersion: step.fromVersion,
-    toVersion: step.toVersion,
-    up: compileMigrationFn(step.up, executor)
-  }));
+  const edgeDocIds = allEdges.map((e) => computeEdgeDocId(e.aUid, e.axbType, e.bUid));
+  const allDocIds = [...edgeDocIds, nodeDocId];
+  const batchSize = Math.min(options?.batchSize ?? MAX_BATCH_SIZE, MAX_BATCH_SIZE);
+  const result = await bulkDeleteDocIds(db2, collectionPath, allDocIds, {
+    ...options,
+    batchSize
+  });
+  const totalChunks = Math.ceil(allDocIds.length / batchSize);
+  const nodeChunkIndex = totalChunks - 1;
+  const nodeDeleted = !result.errors.some((e) => e.batchIndex === nodeChunkIndex);
+  const topLevelEdgesDeleted = nodeDeleted ? result.deleted - 1 : result.deleted;
+  return {
+    deleted: result.deleted + subcollectionResult.deleted,
+    batches: result.batches,
+    errors: [...result.errors, ...subcollectionResult.errors],
+    edgesDeleted: topLevelEdgesDeleted,
+    nodeDeleted
+  };
 }
 
-// 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 }
-      ]
+// src/internal/firestore-backend.ts
+init_serialization();
+
+// src/internal/firestore-adapter.ts
+function createFirestoreAdapter(db2, collectionPath) {
+  const collectionRef = db2.collection(collectionPath);
+  return {
+    collectionPath,
+    async getDoc(docId) {
+      const snap = await collectionRef.doc(docId).get();
+      if (!snap.exists) return null;
+      return snap.data();
     },
-    to: {
-      oneOf: [
-        { type: "string", minLength: 1 },
-        { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 }
-      ]
+    async setDoc(docId, data) {
+      await collectionRef.doc(docId).set(data);
     },
-    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 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"
-  }
-];
-function createBootstrapRegistry() {
-  return createRegistry([...BOOTSTRAP_ENTRIES]);
-}
-function generateDeterministicUid(metaType, name) {
-  const hash2 = createHash3("sha256").update(`${metaType}:${name}`).digest("base64url");
-  return hash2.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 record2 of nodeTypes) {
-    const data = record2.data;
-    if (data.migrations) {
-      for (const m of data.migrations) {
-        prevalidations.push(precompileSource(m.up, executor));
+    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);
       }
-    }
-  }
-  for (const record2 of edgeTypes) {
-    const data = record2.data;
-    if (data.migrations) {
-      for (const m of data.migrations) {
-        prevalidations.push(precompileSource(m.up, executor));
+      if (options?.orderBy) {
+        q = q.orderBy(options.orderBy.field, options.orderBy.direction ?? "asc");
       }
-    }
-  }
-  await Promise.all(prevalidations);
-  for (const record2 of nodeTypes) {
-    const data = record2.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
-    });
-  }
-  for (const record2 of edgeTypes) {
-    const data = record2.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
-        });
+      if (options?.limit !== void 0) {
+        q = q.limit(options.limit);
       }
+      const snap = await q.get();
+      return snap.docs.map((doc) => doc.data());
     }
-  }
-  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(db2, collectionPath, options, scopePath = "") {
-    this.db = db2;
-    this.scopePath = scopePath;
-    this.adapter = createFirestoreAdapter(db2, 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;
+function createTransactionAdapter(db2, collectionPath, tx) {
+  const collectionRef = db2.collection(collectionPath);
+  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);
       }
-      const metaCollectionPath = options.registryMode.collection;
-      if (metaCollectionPath && metaCollectionPath !== collectionPath) {
-        this.metaAdapter = createFirestoreAdapter(db2, metaCollectionPath);
+      if (options?.orderBy) {
+        q = q.orderBy(options.orderBy.field, options.orderBy.direction ?? "asc");
       }
-    } 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") {
-      this.pipelineAdapter = createPipelineQueryAdapter(db2, collectionPath);
-      if (this.metaAdapter) {
-        this.metaPipelineAdapter = createPipelineQueryAdapter(
-          db2,
-          options.registryMode.collection
-        );
+      if (options?.limit !== void 0) {
+        q = q.limit(options.limit);
       }
+      const snap = await tx.get(q);
+      return snap.docs.map((doc) => doc.data());
     }
-  }
-  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;
-  }
-  // ---------------------------------------------------------------------------
-  // 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) {
-    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);
+  };
+}
+function createBatchAdapter(db2, collectionPath) {
+  const collectionRef = db2.collection(collectionPath);
+  const batch = db2.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();
     }
-    console.warn(`[firegraph] Query safety warning: ${result.reason}`);
+  };
+}
+
+// src/internal/pipeline-adapter.ts
+var _Pipelines = null;
+async function getPipelines() {
+  if (!_Pipelines) {
+    const mod = await import("@google-cloud/firestore");
+    _Pipelines = mod.Pipelines;
   }
-  // ---------------------------------------------------------------------------
-  // Migration helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * Apply migration to a single record. Returns the (possibly migrated)
-   * record and triggers write-back if applicable.
-   */
-  async applyMigration(record2, docId) {
-    const registry2 = this.getCombinedRegistry();
-    if (!registry2) return record2;
-    const result = await migrateRecord(record2, registry2, this.globalWriteBack);
-    if (result.migrated) {
-      this.handleWriteBack(result, docId);
-    }
-    return result.record;
+  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}`);
   }
-  /**
-   * Apply migrations to an array of records. Returns all records
-   * (migrated where applicable) and triggers write-backs.
-   */
-  async applyMigrations(records) {
-    const registry2 = this.getCombinedRegistry();
-    if (!registry2 || records.length === 0) return records;
-    const results = await migrateRecords(records, registry2, 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);
+}
+function createPipelineQueryAdapter(db2, collectionPath) {
+  return {
+    async query(filters, options) {
+      const P = await getPipelines();
+      let pipeline = db2.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());
+    }
+  };
+}
+
+// src/internal/firestore-backend.ts
+function buildFirestoreUpdate(update, db2) {
+  const out = {
+    updatedAt: FieldValue2.serverTimestamp()
+  };
+  if (update.replaceData) {
+    out.data = deserializeFirestoreTypes(update.replaceData, db2);
+  }
+  if (update.dataFields) {
+    for (const [k, v] of Object.entries(update.dataFields)) {
+      out[`data.${k}`] = v;
     }
-    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();
+  if (update.v !== void 0) {
+    out.v = update.v;
   }
-  // ---------------------------------------------------------------------------
-  // GraphReader
-  // ---------------------------------------------------------------------------
-  async getNode(uid) {
-    const docId = computeNodeDocId(uid);
-    const record2 = await this.adapter.getDoc(docId);
-    if (!record2) return null;
-    return this.applyMigration(record2, docId);
+  return out;
+}
+function stampWritableRecord(record2) {
+  const now = FieldValue2.serverTimestamp();
+  const out = {
+    aType: record2.aType,
+    aUid: record2.aUid,
+    axbType: record2.axbType,
+    bType: record2.bType,
+    bUid: record2.bUid,
+    data: record2.data,
+    createdAt: now,
+    updatedAt: now
+  };
+  if (record2.v !== void 0) out.v = record2.v;
+  return out;
+}
+var FirestoreTransactionBackend = class {
+  constructor(adapter, db2) {
+    this.adapter = adapter;
+    this.db = db2;
   }
-  async getEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record2 = await this.adapter.getDoc(docId);
-    if (!record2) return null;
-    return this.applyMigration(record2, docId);
+  getDoc(docId) {
+    return this.adapter.getDoc(docId);
   }
-  async edgeExists(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record2 = await this.adapter.getDoc(docId);
-    return record2 !== null;
+  query(filters, options) {
+    return this.adapter.query(filters, options);
   }
-  async findEdges(params) {
-    const plan = buildEdgeQueryPlan(params);
-    let records;
-    if (plan.strategy === "get") {
-      const record2 = await this.adapter.getDoc(plan.docId);
-      records = record2 ? [record2] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.executeQuery(plan.filters, plan.options);
-    }
-    return this.applyMigrations(records);
+  async setDoc(docId, record2) {
+    this.adapter.setDoc(docId, stampWritableRecord(record2));
   }
-  async findNodes(params) {
-    const plan = buildNodeQueryPlan(params);
-    let records;
-    if (plan.strategy === "get") {
-      const record2 = await this.adapter.getDoc(plan.docId);
-      records = record2 ? [record2] : [];
-    } else {
-      this.checkQuerySafety(plan.filters, params.allowCollectionScan);
-      records = await this.executeQuery(plan.filters, plan.options);
-    }
-    return this.applyMigrations(records);
+  async updateDoc(docId, update) {
+    this.adapter.updateDoc(docId, buildFirestoreUpdate(update, this.db));
   }
-  // ---------------------------------------------------------------------------
-  // GraphWriter
-  // ---------------------------------------------------------------------------
-  async putNode(aType, uid, data) {
-    const registry2 = this.getRegistryForType(aType);
-    if (registry2) {
-      registry2.validate(aType, NODE_RELATION, aType, data, this.scopePath);
-    }
-    const adapter = this.getAdapterForType(aType);
-    const docId = computeNodeDocId(uid);
-    const record2 = buildNodeRecord(aType, uid, data);
-    if (registry2) {
-      const entry = registry2.lookup(aType, NODE_RELATION, aType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record2.v = entry.schemaVersion;
-      }
-    }
-    await adapter.setDoc(docId, record2);
+  async deleteDoc(docId) {
+    this.adapter.deleteDoc(docId);
   }
-  async putEdge(aType, aUid, axbType, bType, bUid, data) {
-    const registry2 = this.getRegistryForType(aType);
-    if (registry2) {
-      registry2.validate(aType, axbType, bType, data, this.scopePath);
-    }
-    const adapter = this.getAdapterForType(aType);
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    const record2 = buildEdgeRecord(aType, aUid, axbType, bType, bUid, data);
-    if (registry2) {
-      const entry = registry2.lookup(aType, axbType, bType);
-      if (entry?.schemaVersion && entry.schemaVersion > 0) {
-        record2.v = entry.schemaVersion;
-      }
+};
+var FirestoreBatchBackend = class {
+  constructor(adapter, db2) {
+    this.adapter = adapter;
+    this.db = db2;
+  }
+  setDoc(docId, record2) {
+    this.adapter.setDoc(docId, stampWritableRecord(record2));
+  }
+  updateDoc(docId, update) {
+    this.adapter.updateDoc(docId, buildFirestoreUpdate(update, this.db));
+  }
+  deleteDoc(docId) {
+    this.adapter.deleteDoc(docId);
+  }
+  commit() {
+    return this.adapter.commit();
+  }
+};
+var FirestoreBackendImpl = class _FirestoreBackendImpl {
+  constructor(db2, collectionPath, queryMode, scopePath) {
+    this.db = db2;
+    this.queryMode = queryMode;
+    this.collectionPath = collectionPath;
+    this.scopePath = scopePath;
+    this.adapter = createFirestoreAdapter(db2, collectionPath);
+    if (queryMode === "pipeline") {
+      this.pipelineAdapter = createPipelineQueryAdapter(db2, collectionPath);
     }
-    await adapter.setDoc(docId, record2);
   }
-  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;
+  collectionPath;
+  scopePath;
+  adapter;
+  pipelineAdapter;
+  // --- Reads ---
+  getDoc(docId) {
+    return this.adapter.getDoc(docId);
+  }
+  query(filters, options) {
+    if (this.pipelineAdapter) {
+      return this.pipelineAdapter.query(filters, options);
     }
-    await this.adapter.updateDoc(docId, update);
+    return this.adapter.query(filters, options);
   }
-  async removeNode(uid) {
-    const docId = computeNodeDocId(uid);
-    await this.adapter.deleteDoc(docId);
+  // --- Writes ---
+  setDoc(docId, record2) {
+    return this.adapter.setDoc(docId, stampWritableRecord(record2));
   }
-  async removeEdge(aUid, axbType, bUid) {
-    const docId = computeEdgeDocId(aUid, axbType, bUid);
-    await this.adapter.deleteDoc(docId);
+  updateDoc(docId, update) {
+    return this.adapter.updateDoc(docId, buildFirestoreUpdate(update, this.db));
   }
-  // ---------------------------------------------------------------------------
-  // Transactions & Batches
-  // ---------------------------------------------------------------------------
-  async runTransaction(fn) {
+  deleteDoc(docId) {
+    return this.adapter.deleteDoc(docId);
+  }
+  // --- 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);
   }
-  // ---------------------------------------------------------------------------
-  // Collection group query
-  // ---------------------------------------------------------------------------
+  // --- Cascade & bulk ---
+  removeNodeCascade(uid, reader, options) {
+    return removeNodeCascade(this.db, this.collectionPath, reader, uid, options);
+  }
+  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(
@@ -31576,183 +31980,47 @@ 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) {
       q = q.where(f.field, f.op, f.value);
     }
-    if (plan.options?.orderBy) {
-      q = q.orderBy(plan.options.orderBy.field, plan.options.orderBy.direction ?? "asc");
-    }
-    if (plan.options?.limit !== void 0) {
-      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;
-    }
+    if (plan.options?.orderBy) {
+      q = q.orderBy(plan.options.orderBy.field, plan.options.orderBy.direction ?? "asc");
+    }
+    if (plan.options?.limit !== void 0) {
+      q = q.limit(plan.options.limit);
+    }
+    const snap = await q.get();
+    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(db2, collectionPath, options = {}) {
+  const queryMode = options.queryMode ?? "pipeline";
+  const scopePath = options.scopePath ?? "";
+  return new FirestoreBackendImpl(db2, collectionPath, queryMode, scopePath);
+}
+
+// src/firestore.ts
+var _standardModeWarned = false;
+function createGraphClient(db2, 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 record2 = await adapter.getDoc(computeEdgeDocId(aUid, axbType, bUid));
-        return record2 !== null;
-      },
-      async findEdges(params) {
-        const plan = buildEdgeQueryPlan(params);
-        if (plan.strategy === "get") {
-          const record2 = await adapter.getDoc(plan.docId);
-          return record2 ? [record2] : [];
-        }
-        return executeMetaQuery(plan.filters, plan.options);
-      },
-      async findNodes(params) {
-        const plan = buildNodeQueryPlan(params);
-        if (plan.strategy === "get") {
-          const record2 = await adapter.getDoc(plan.docId);
-          return record2 ? [record2] : [];
-        }
-        return executeMetaQuery(plan.filters, plan.options);
-      }
-    };
+  const backend = createFirestoreBackend(db2, collectionPath, { queryMode: effectiveMode });
+  let metaBackend;
+  if (options?.registryMode?.collection && options.registryMode.collection !== collectionPath) {
+    metaBackend = createFirestoreBackend(db2, options.registryMode.collection, {
+      queryMode: effectiveMode
+    });
   }
-};
-function createGraphClient(db2, collectionPath, options) {
-  return new GraphClientImpl(db2, collectionPath, options);
+  return new GraphClientImpl(backend, options, metaBackend);
 }
 
 // node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
@@ -31790,209 +32058,11 @@ function generateId() {
   return nanoid();
 }
 
-// src/discover.ts
-import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
-import { createRequire } from "node:module";
-import { join, resolve } from "node: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: createJiti2 } = esmRequire("jiti");
-    _jiti = createJiti2(base, { interopDefault: true });
-  }
-  return _jiti;
-}
-function loadSchemaModule(filePath, entityLabel) {
-  try {
-    const jiti2 = getJiti();
-    const mod = jiti2(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 jiti2 = getJiti();
-    const mod = jiti2(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 meta3 = 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: meta3?.description,
-    titleField: meta3?.titleField,
-    subtitleField: meta3?.subtitleField,
-    viewDefaults: meta3?.viewDefaults,
-    viewsPath,
-    sampleData,
-    allowedIn: meta3?.allowedIn,
-    migrations,
-    migrationWriteBack: meta3?.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 meta3 = 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: meta3?.description,
-    titleField: meta3?.titleField,
-    subtitleField: meta3?.subtitleField,
-    viewDefaults: meta3?.viewDefaults,
-    viewsPath,
-    sampleData,
-    allowedIn: meta3?.allowedIn,
-    targetGraph: topology.targetGraph ?? meta3?.targetGraph,
-    migrations,
-    migrationWriteBack: meta3?.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/record.ts
+import { FieldValue as FieldValue3 } from "@google-cloud/firestore";
+
+// src/index.ts
+init_serialization();
 
 // editor/server/schema-introspect.ts
 function introspectRegistry(registry2, dynamicNames) {