@typicalday/firegraph 0.1.0

package/dist/index.js

@@ -0,0 +1,1569 @@
+import {
+  generateTypes
+} from "./chunk-YLGXLEUE.js";
+import {
+  QueryClient,
+  QueryClientError
+} from "./chunk-KFA7G37W.js";
+
+// src/client.ts
+import { FieldValue as FieldValue4 } from "@google-cloud/firestore";
+
+// src/docid.ts
+import { createHash } from "crypto";
+
+// src/internal/constants.ts
+var NODE_RELATION = "is";
+var SHARD_SEPARATOR = ":";
+
+// src/docid.ts
+function computeNodeDocId(uid) {
+  return uid;
+}
+function computeEdgeDocId(aUid, axbType, bUid) {
+  const composite = `${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
+  const hash = createHash("sha256").update(composite).digest("hex");
+  const shard = hash[0];
+  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
+  };
+}
+function buildEdgeRecord(aType, aUid, axbType, bType, bUid, data) {
+  const now = FieldValue.serverTimestamp();
+  return {
+    aType,
+    aUid,
+    axbType,
+    bType,
+    bUid,
+    data,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+
+// src/errors.ts
+var FiregraphError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FiregraphError";
+  }
+};
+var NodeNotFoundError = class extends FiregraphError {
+  constructor(uid) {
+    super(`Node not found: ${uid}`, "NODE_NOT_FOUND");
+    this.name = "NodeNotFoundError";
+  }
+};
+var EdgeNotFoundError = class extends FiregraphError {
+  constructor(aUid, axbType, bUid) {
+    super(`Edge not found: ${aUid} -[${axbType}]-> ${bUid}`, "EDGE_NOT_FOUND");
+    this.name = "EdgeNotFoundError";
+  }
+};
+var ValidationError = class extends FiregraphError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR");
+    this.details = details;
+    this.name = "ValidationError";
+  }
+};
+var RegistryViolationError = class extends FiregraphError {
+  constructor(aType, axbType, bType) {
+    super(
+      `Unregistered triple: (${aType}) -[${axbType}]-> (${bType})`,
+      "REGISTRY_VIOLATION"
+    );
+    this.name = "RegistryViolationError";
+  }
+};
+var InvalidQueryError = class extends FiregraphError {
+  constructor(message) {
+    super(message, "INVALID_QUERY");
+    this.name = "InvalidQueryError";
+  }
+};
+var TraversalError = class extends FiregraphError {
+  constructor(message) {
+    super(message, "TRAVERSAL_ERROR");
+    this.name = "TraversalError";
+  }
+};
+var DynamicRegistryError = class extends FiregraphError {
+  constructor(message) {
+    super(message, "DYNAMIC_REGISTRY_ERROR");
+    this.name = "DynamicRegistryError";
+  }
+};
+
+// 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 });
+  const builtinFields = ["aType", "aUid", "axbType", "bType", "bUid", "createdAt", "updatedAt"];
+  if (params.where) {
+    for (const clause of params.where) {
+      const field = builtinFields.includes(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 options = limit !== void 0 || orderBy ? { limit, orderBy } : void 0;
+  return { strategy: "query", filters, options };
+}
+function buildNodeQueryPlan(params) {
+  return {
+    strategy: "query",
+    filters: [
+      { field: "aType", op: "==", value: params.aType },
+      { field: "axbType", op: "==", value: NODE_RELATION }
+    ]
+  };
+}
+
+// src/internal/firestore-adapter.ts
+function createFirestoreAdapter(db, collectionPath) {
+  const collectionRef = db.collection(collectionPath);
+  return {
+    collectionPath,
+    async getDoc(docId) {
+      const snap = await collectionRef.doc(docId).get();
+      if (!snap.exists) return null;
+      return snap.data();
+    },
+    async setDoc(docId, data) {
+      await collectionRef.doc(docId).set(data);
+    },
+    async updateDoc(docId, data) {
+      await collectionRef.doc(docId).update(data);
+    },
+    async deleteDoc(docId) {
+      await collectionRef.doc(docId).delete();
+    },
+    async query(filters, options) {
+      let q = collectionRef;
+      for (const f of filters) {
+        q = q.where(f.field, f.op, f.value);
+      }
+      if (options?.orderBy) {
+        q = q.orderBy(options.orderBy.field, options.orderBy.direction ?? "asc");
+      }
+      if (options?.limit !== void 0) {
+        q = q.limit(options.limit);
+      }
+      const snap = await q.get();
+      return snap.docs.map((doc) => doc.data());
+    }
+  };
+}
+function createTransactionAdapter(db, collectionPath, tx) {
+  const collectionRef = db.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 createBatchAdapter(db, collectionPath) {
+  const collectionRef = db.collection(collectionPath);
+  const batch = db.batch();
+  return {
+    setDoc(docId, data) {
+      batch.set(collectionRef.doc(docId), data);
+    },
+    updateDoc(docId, data) {
+      batch.update(collectionRef.doc(docId), data);
+    },
+    deleteDoc(docId) {
+      batch.delete(collectionRef.doc(docId));
+    },
+    async commit() {
+      await batch.commit();
+    }
+  };
+}
+
+// src/internal/pipeline-adapter.ts
+var _Pipelines = null;
+async function getPipelines() {
+  if (!_Pipelines) {
+    const mod = await import("@google-cloud/firestore");
+    _Pipelines = mod.Pipelines;
+  }
+  return _Pipelines;
+}
+function buildFilterExpression(P, filter) {
+  const { field: fieldName, op, value } = filter;
+  switch (op) {
+    case "==":
+      return P.equal(fieldName, value);
+    case "!=":
+      return P.notEqual(fieldName, value);
+    case "<":
+      return P.lessThan(fieldName, value);
+    case "<=":
+      return P.lessThanOrEqual(fieldName, value);
+    case ">":
+      return P.greaterThan(fieldName, value);
+    case ">=":
+      return P.greaterThanOrEqual(fieldName, value);
+    case "in":
+      return P.equalAny(fieldName, value);
+    case "not-in":
+      return P.notEqualAny(fieldName, value);
+    case "array-contains":
+      return P.arrayContains(fieldName, value);
+    case "array-contains-any":
+      return P.arrayContainsAny(fieldName, value);
+    default:
+      throw new Error(`Unsupported filter op for pipeline mode: ${op}`);
+  }
+}
+function createPipelineQueryAdapter(db, collectionPath) {
+  return {
+    async query(filters, options) {
+      const P = await getPipelines();
+      let pipeline = db.pipeline().collection(collectionPath);
+      if (filters.length === 1) {
+        pipeline = pipeline.where(buildFilterExpression(P, filters[0]));
+      } else if (filters.length > 1) {
+        const [first, second, ...rest] = filters.map((f) => buildFilterExpression(P, f));
+        pipeline = pipeline.where(P.and(first, second, ...rest));
+      }
+      if (options?.orderBy) {
+        const f = P.field(options.orderBy.field);
+        const ordering = options.orderBy.direction === "desc" ? f.descending() : f.ascending();
+        pipeline = pipeline.sort(ordering);
+      }
+      if (options?.limit !== void 0) {
+        pipeline = pipeline.limit(options.limit);
+      }
+      const snap = await pipeline.execute();
+      return snap.results.map((r) => r.data());
+    }
+  };
+}
+
+// src/transaction.ts
+import { FieldValue as FieldValue2 } from "@google-cloud/firestore";
+var GraphTransactionImpl = class {
+  constructor(adapter, registry) {
+    this.adapter = adapter;
+    this.registry = registry;
+  }
+  async getNode(uid) {
+    const docId = computeNodeDocId(uid);
+    return this.adapter.getDoc(docId);
+  }
+  async getEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    return this.adapter.getDoc(docId);
+  }
+  async edgeExists(aUid, axbType, bUid) {
+    const record = await this.getEdge(aUid, axbType, bUid);
+    return record !== null;
+  }
+  async findEdges(params) {
+    const plan = buildEdgeQueryPlan(params);
+    if (plan.strategy === "get") {
+      const record = await this.adapter.getDoc(plan.docId);
+      return record ? [record] : [];
+    }
+    return this.adapter.query(plan.filters, plan.options);
+  }
+  async findNodes(params) {
+    const plan = buildNodeQueryPlan(params);
+    if (plan.strategy === "get") {
+      const record = await this.adapter.getDoc(plan.docId);
+      return record ? [record] : [];
+    }
+    return this.adapter.query(plan.filters, plan.options);
+  }
+  async putNode(aType, uid, data) {
+    if (this.registry) {
+      this.registry.validate(aType, NODE_RELATION, aType, data);
+    }
+    const docId = computeNodeDocId(uid);
+    const record = buildNodeRecord(aType, uid, data);
+    this.adapter.setDoc(docId, record);
+  }
+  async putEdge(aType, aUid, axbType, bType, bUid, data) {
+    if (this.registry) {
+      this.registry.validate(aType, axbType, bType, data);
+    }
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record = buildEdgeRecord(aType, aUid, axbType, bType, bUid, data);
+    this.adapter.setDoc(docId, record);
+  }
+  async updateNode(uid, data) {
+    const docId = computeNodeDocId(uid);
+    this.adapter.updateDoc(docId, {
+      ...data,
+      updatedAt: FieldValue2.serverTimestamp()
+    });
+  }
+  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 FieldValue3 } from "@google-cloud/firestore";
+var GraphBatchImpl = class {
+  constructor(adapter, registry) {
+    this.adapter = adapter;
+    this.registry = registry;
+  }
+  async putNode(aType, uid, data) {
+    if (this.registry) {
+      this.registry.validate(aType, NODE_RELATION, aType, data);
+    }
+    const docId = computeNodeDocId(uid);
+    const record = buildNodeRecord(aType, uid, data);
+    this.adapter.setDoc(docId, record);
+  }
+  async putEdge(aType, aUid, axbType, bType, bUid, data) {
+    if (this.registry) {
+      this.registry.validate(aType, axbType, bType, data);
+    }
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record = buildEdgeRecord(aType, aUid, axbType, bType, bUid, data);
+    this.adapter.setDoc(docId, record);
+  }
+  async updateNode(uid, data) {
+    const docId = computeNodeDocId(uid);
+    this.adapter.updateDoc(docId, {
+      ...data,
+      updatedAt: FieldValue3.serverTimestamp()
+    });
+  }
+  async removeNode(uid) {
+    const docId = computeNodeDocId(uid);
+    this.adapter.deleteDoc(docId);
+  }
+  async removeEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    this.adapter.deleteDoc(docId);
+  }
+  async commit() {
+    await this.adapter.commit();
+  }
+};
+
+// src/bulk.ts
+var MAX_BATCH_SIZE = 500;
+var DEFAULT_MAX_RETRIES = 3;
+var BASE_DELAY_MS = 200;
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function chunk(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+async function bulkDeleteDocIds(db, collectionPath, docIds, options) {
+  if (docIds.length === 0) {
+    return { deleted: 0, batches: 0, errors: [] };
+  }
+  const batchSize = Math.min(options?.batchSize ?? MAX_BATCH_SIZE, MAX_BATCH_SIZE);
+  const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const onProgress = options?.onProgress;
+  const chunks = chunk(docIds, batchSize);
+  const errors = [];
+  let deleted = 0;
+  let completedBatches = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const ids = chunks[i];
+    let committed = false;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const batch = db.batch();
+        const collectionRef = db.collection(collectionPath);
+        for (const id of ids) {
+          batch.delete(collectionRef.doc(id));
+        }
+        await batch.commit();
+        committed = true;
+        deleted += ids.length;
+        break;
+      } catch (err) {
+        if (attempt < maxRetries) {
+          const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+          await sleep(delay);
+        } else {
+          errors.push({
+            batchIndex: i,
+            error: err instanceof Error ? err : new Error(String(err)),
+            operationCount: ids.length
+          });
+        }
+      }
+    }
+    if (committed) {
+      completedBatches++;
+    }
+    if (onProgress) {
+      onProgress({
+        completedBatches,
+        totalBatches: chunks.length,
+        deletedSoFar: deleted
+      });
+    }
+  }
+  return { deleted, batches: completedBatches, errors };
+}
+async function bulkRemoveEdges(db, collectionPath, reader, params, options) {
+  const edges = await reader.findEdges(params);
+  const docIds = edges.map((e) => computeEdgeDocId(e.aUid, e.axbType, e.bUid));
+  return bulkDeleteDocIds(db, collectionPath, docIds, options);
+}
+async function removeNodeCascade(db, collectionPath, reader, uid, options) {
+  const [outgoingRaw, incomingRaw] = await Promise.all([
+    reader.findEdges({ aUid: uid }),
+    reader.findEdges({ bUid: uid })
+  ]);
+  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 edgeDocIds = allEdges.map((e) => computeEdgeDocId(e.aUid, e.axbType, e.bUid));
+  const nodeDocId = computeNodeDocId(uid);
+  const allDocIds = [...edgeDocIds, nodeDocId];
+  const batchSize = Math.min(options?.batchSize ?? MAX_BATCH_SIZE, MAX_BATCH_SIZE);
+  const result = await bulkDeleteDocIds(db, collectionPath, allDocIds, {
+    ...options,
+    batchSize
+  });
+  const totalChunks = Math.ceil(allDocIds.length / batchSize);
+  const nodeChunkIndex = totalChunks - 1;
+  const nodeDeleted = !result.errors.some((e) => e.batchIndex === nodeChunkIndex);
+  return {
+    ...result,
+    edgesDeleted: nodeDeleted ? result.deleted - 1 : result.deleted,
+    nodeDeleted
+  };
+}
+
+// src/dynamic-registry.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/json-schema.ts
+import Ajv from "ajv";
+var ajv = new Ajv({ allErrors: true, strict: false });
+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, required) {
+  if (!prop) return { name, type: "unknown", required };
+  if (Array.isArray(prop.enum)) {
+    return {
+      name,
+      type: "enum",
+      required,
+      enumValues: prop.enum,
+      description: prop.description
+    };
+  }
+  if (Array.isArray(prop.oneOf) || Array.isArray(prop.anyOf)) {
+    const variants = prop.oneOf ?? prop.anyOf;
+    const nonNull = variants.filter((v) => v.type !== "null");
+    if (nonNull.length === 1) {
+      return propertyToFieldMeta(name, nonNull[0], false);
+    }
+    return { name, type: "unknown", required, description: prop.description };
+  }
+  const type = prop.type;
+  if (type === "string") {
+    return {
+      name,
+      type: "string",
+      required,
+      minLength: prop.minLength,
+      maxLength: prop.maxLength,
+      pattern: prop.pattern,
+      description: prop.description
+    };
+  }
+  if (type === "number" || type === "integer") {
+    return {
+      name,
+      type: "number",
+      required,
+      min: prop.minimum,
+      max: prop.maximum,
+      isInt: type === "integer" ? true : void 0,
+      description: prop.description
+    };
+  }
+  if (type === "boolean") {
+    return { name, type: "boolean", required, description: prop.description };
+  }
+  if (type === "array") {
+    const itemMeta = prop.items ? propertyToFieldMeta("item", prop.items, true) : void 0;
+    return {
+      name,
+      type: "array",
+      required,
+      itemMeta,
+      description: prop.description
+    };
+  }
+  if (type === "object") {
+    return {
+      name,
+      type: "object",
+      required,
+      fields: jsonSchemaToFieldMeta(prop),
+      description: prop.description
+    };
+  }
+  return { name, type: "unknown", required, description: prop.description };
+}
+
+// src/registry.ts
+function tripleKey(aType, axbType, bType) {
+  return `${aType}:${axbType}:${bType}`;
+}
+function createRegistry(input) {
+  const map = /* @__PURE__ */ new Map();
+  let entries;
+  if (Array.isArray(input)) {
+    entries = input;
+  } else {
+    entries = discoveryToEntries(input);
+  }
+  const entryList = Object.freeze([...entries]);
+  for (const entry of entries) {
+    const key = tripleKey(entry.aType, entry.axbType, entry.bType);
+    const validator = entry.jsonSchema ? compileSchema(entry.jsonSchema, `(${entry.aType}) -[${entry.axbType}]-> (${entry.bType})`) : void 0;
+    map.set(key, { entry, validate: validator });
+  }
+  return {
+    lookup(aType, axbType, bType) {
+      return map.get(tripleKey(aType, axbType, bType))?.entry;
+    },
+    validate(aType, axbType, bType, data) {
+      const rec = map.get(tripleKey(aType, axbType, bType));
+      if (!rec) {
+        throw new RegistryViolationError(aType, axbType, bType);
+      }
+      if (rec.validate) {
+        try {
+          rec.validate(data);
+        } catch (err) {
+          if (err instanceof ValidationError) throw err;
+          throw new ValidationError(
+            `Data validation failed for (${aType}) -[${axbType}]-> (${bType})`,
+            err
+          );
+        }
+      }
+    },
+    entries() {
+      return entryList;
+    }
+  };
+}
+function 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
+    });
+  }
+  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];
+    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
+        });
+      }
+    }
+  }
+  return entries;
+}
+
+// src/dynamic-registry.ts
+var META_NODE_TYPE = "nodeType";
+var META_EDGE_TYPE = "edgeType";
+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" }
+  },
+  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" }
+  },
+  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 hash = createHash2("sha256").update(`${metaType}:${name}`).digest("base64url");
+  return hash.slice(0, 21);
+}
+async function createRegistryFromGraph(reader) {
+  const [nodeTypes, edgeTypes] = await Promise.all([
+    reader.findNodes({ aType: META_NODE_TYPE }),
+    reader.findNodes({ aType: META_EDGE_TYPE })
+  ]);
+  const entries = [...BOOTSTRAP_ENTRIES];
+  for (const record of nodeTypes) {
+    const data = record.data;
+    entries.push({
+      aType: data.name,
+      axbType: NODE_RELATION,
+      bType: data.name,
+      jsonSchema: data.jsonSchema,
+      description: data.description,
+      titleField: data.titleField,
+      subtitleField: data.subtitleField
+    });
+  }
+  for (const record of edgeTypes) {
+    const data = record.data;
+    const fromTypes = Array.isArray(data.from) ? data.from : [data.from];
+    const toTypes = Array.isArray(data.to) ? data.to : [data.to];
+    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
+        });
+      }
+    }
+  }
+  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 {
+  constructor(db, collectionPath, options) {
+    this.db = db;
+    this.adapter = createFirestoreAdapter(db, collectionPath);
+    if (options?.registry && options?.registryMode) {
+      throw new DynamicRegistryError(
+        'Cannot provide both "registry" and "registryMode". Use "registry" for static mode or "registryMode" for dynamic mode.'
+      );
+    }
+    if (options?.registryMode) {
+      this.dynamicConfig = options.registryMode;
+      this.bootstrapRegistry = createBootstrapRegistry();
+      const metaCollectionPath = options.registryMode.collection;
+      if (metaCollectionPath && metaCollectionPath !== collectionPath) {
+        this.metaAdapter = createFirestoreAdapter(db, metaCollectionPath);
+      }
+    } else {
+      this.staticRegistry = options?.registry;
+    }
+    const requestedMode = options?.queryMode ?? "pipeline";
+    const isEmulator = !!process.env.FIRESTORE_EMULATOR_HOST;
+    if (isEmulator) {
+      this.queryMode = "standard";
+    } else {
+      this.queryMode = requestedMode;
+    }
+    if (this.queryMode === "standard" && !isEmulator && requestedMode === "standard" && !_standardModeWarned) {
+      _standardModeWarned = true;
+      console.warn(
+        "[firegraph] Standard query mode enabled. This is NOT recommended for production:\n  - Enterprise Firestore: data.* filters cause full collection scans (high billing)\n  - Standard Firestore: data.* filters without composite indexes will fail\n  See: https://github.com/typicalday/firegraph#query-modes"
+      );
+    }
+    if (this.queryMode === "pipeline") {
+      this.pipelineAdapter = createPipelineQueryAdapter(db, collectionPath);
+      if (this.metaAdapter) {
+        this.metaPipelineAdapter = createPipelineQueryAdapter(
+          db,
+          options.registryMode.collection
+        );
+      }
+    }
+  }
+  adapter;
+  pipelineAdapter;
+  queryMode;
+  // Static mode
+  staticRegistry;
+  // Dynamic mode
+  dynamicConfig;
+  bootstrapRegistry;
+  dynamicRegistry;
+  metaAdapter;
+  metaPipelineAdapter;
+  // ---------------------------------------------------------------------------
+  // Registry routing
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the appropriate registry for validating a write to the given type.
+   *
+   * - Static mode: returns staticRegistry (or undefined if none set)
+   * - Dynamic mode:
+   *   - Meta-types (nodeType, edgeType): validated against bootstrapRegistry
+   *   - Domain types: validated against dynamicRegistry (falls back to
+   *     bootstrapRegistry which rejects unknown types)
+   */
+  getRegistryForType(aType) {
+    if (!this.dynamicConfig) return this.staticRegistry;
+    if (aType === META_NODE_TYPE || aType === META_EDGE_TYPE) {
+      return this.bootstrapRegistry;
+    }
+    return this.dynamicRegistry ?? 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 mode, returns staticRegistry.
+   * In dynamic mode, returns dynamicRegistry (which includes bootstrap entries)
+   * or bootstrapRegistry if not yet reloaded.
+   */
+  getCombinedRegistry() {
+    if (!this.dynamicConfig) return this.staticRegistry;
+    return this.dynamicRegistry ?? 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);
+  }
+  // ---------------------------------------------------------------------------
+  // GraphReader
+  // ---------------------------------------------------------------------------
+  async getNode(uid) {
+    const docId = computeNodeDocId(uid);
+    return this.adapter.getDoc(docId);
+  }
+  async getEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    return this.adapter.getDoc(docId);
+  }
+  async edgeExists(aUid, axbType, bUid) {
+    const record = await this.getEdge(aUid, axbType, bUid);
+    return record !== null;
+  }
+  async findEdges(params) {
+    const plan = buildEdgeQueryPlan(params);
+    if (plan.strategy === "get") {
+      const record = await this.adapter.getDoc(plan.docId);
+      return record ? [record] : [];
+    }
+    return this.executeQuery(plan.filters, plan.options);
+  }
+  async findNodes(params) {
+    const plan = buildNodeQueryPlan(params);
+    if (plan.strategy === "get") {
+      const record = await this.adapter.getDoc(plan.docId);
+      return record ? [record] : [];
+    }
+    return this.executeQuery(plan.filters, plan.options);
+  }
+  // ---------------------------------------------------------------------------
+  // GraphWriter
+  // ---------------------------------------------------------------------------
+  async putNode(aType, uid, data) {
+    const registry = this.getRegistryForType(aType);
+    if (registry) {
+      registry.validate(aType, NODE_RELATION, aType, data);
+    }
+    const adapter = this.getAdapterForType(aType);
+    const docId = computeNodeDocId(uid);
+    const record = buildNodeRecord(aType, uid, data);
+    await adapter.setDoc(docId, record);
+  }
+  async putEdge(aType, aUid, axbType, bType, bUid, data) {
+    const registry = this.getRegistryForType(aType);
+    if (registry) {
+      registry.validate(aType, axbType, bType, data);
+    }
+    const adapter = this.getAdapterForType(aType);
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    const record = buildEdgeRecord(aType, aUid, axbType, bType, bUid, data);
+    await adapter.setDoc(docId, record);
+  }
+  async updateNode(uid, data) {
+    const docId = computeNodeDocId(uid);
+    await this.adapter.updateDoc(docId, {
+      ...data,
+      updatedAt: FieldValue4.serverTimestamp()
+    });
+  }
+  async removeNode(uid) {
+    const docId = computeNodeDocId(uid);
+    await this.adapter.deleteDoc(docId);
+  }
+  async removeEdge(aUid, axbType, bUid) {
+    const docId = computeEdgeDocId(aUid, axbType, bUid);
+    await this.adapter.deleteDoc(docId);
+  }
+  // ---------------------------------------------------------------------------
+  // Transactions & Batches
+  // ---------------------------------------------------------------------------
+  async runTransaction(fn) {
+    return this.db.runTransaction(async (firestoreTx) => {
+      const adapter = createTransactionAdapter(
+        this.db,
+        this.adapter.collectionPath,
+        firestoreTx
+      );
+      const graphTx = new GraphTransactionImpl(adapter, this.getCombinedRegistry());
+      return fn(graphTx);
+    });
+  }
+  batch() {
+    const adapter = createBatchAdapter(this.db, this.adapter.collectionPath);
+    return new GraphBatchImpl(adapter, this.getCombinedRegistry());
+  }
+  // ---------------------------------------------------------------------------
+  // 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.`
+      );
+    }
+    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;
+    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.`
+      );
+    }
+    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 (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;
+    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();
+    this.dynamicRegistry = await createRegistryFromGraph(reader);
+  }
+  /**
+   * Create a GraphReader for the meta-collection.
+   * If meta-collection is the same as main collection, returns `this`.
+   * If separate, creates a lightweight reader wrapping the meta adapter.
+   */
+  createMetaReader() {
+    if (!this.metaAdapter) return this;
+    const adapter = this.metaAdapter;
+    const pipelineAdapter = this.metaPipelineAdapter;
+    const executeMetaQuery = (filters, options) => {
+      if (pipelineAdapter) return pipelineAdapter.query(filters, options);
+      return adapter.query(filters, options);
+    };
+    return {
+      async getNode(uid) {
+        return adapter.getDoc(computeNodeDocId(uid));
+      },
+      async getEdge(aUid, axbType, bUid) {
+        return adapter.getDoc(computeEdgeDocId(aUid, axbType, bUid));
+      },
+      async edgeExists(aUid, axbType, bUid) {
+        const record = await adapter.getDoc(computeEdgeDocId(aUid, axbType, bUid));
+        return record !== null;
+      },
+      async findEdges(params) {
+        const plan = buildEdgeQueryPlan(params);
+        if (plan.strategy === "get") {
+          const record = await adapter.getDoc(plan.docId);
+          return record ? [record] : [];
+        }
+        return executeMetaQuery(plan.filters, plan.options);
+      },
+      async findNodes(params) {
+        const plan = buildNodeQueryPlan(params);
+        if (plan.strategy === "get") {
+          const record = await adapter.getDoc(plan.docId);
+          return record ? [record] : [];
+        }
+        return executeMetaQuery(plan.filters, plan.options);
+      }
+    };
+  }
+};
+function createGraphClient(db, collectionPath, options) {
+  return new GraphClientImpl(db, collectionPath, options);
+}
+
+// src/id.ts
+import { nanoid } from "nanoid";
+function generateId() {
+  return nanoid();
+}
+
+// src/traverse.ts
+var DEFAULT_LIMIT = 10;
+var DEFAULT_MAX_READS = 100;
+var DEFAULT_CONCURRENCY = 5;
+var Semaphore = class {
+  constructor(slots) {
+    this.slots = slots;
+  }
+  queue = [];
+  active = 0;
+  async acquire() {
+    if (this.active < this.slots) {
+      this.active++;
+      return;
+    }
+    return new Promise((resolve2) => {
+      this.queue.push(resolve2);
+    });
+  }
+  release() {
+    this.active--;
+    const next = this.queue.shift();
+    if (next) {
+      this.active++;
+      next();
+    }
+  }
+};
+var TraversalBuilderImpl = class {
+  constructor(reader, startUid) {
+    this.reader = reader;
+    this.startUid = startUid;
+  }
+  hops = [];
+  follow(axbType, options) {
+    this.hops.push({ axbType, ...options });
+    return this;
+  }
+  async run(options) {
+    if (this.hops.length === 0) {
+      throw new TraversalError("Traversal requires at least one follow() hop");
+    }
+    const maxReads = options?.maxReads ?? DEFAULT_MAX_READS;
+    const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
+    const returnIntermediates = options?.returnIntermediates ?? false;
+    const semaphore = new Semaphore(concurrency);
+    let totalReads = 0;
+    let truncated = false;
+    let sourceUids = [this.startUid];
+    const hopResults = [];
+    for (let depth = 0; depth < this.hops.length; depth++) {
+      const hop = this.hops[depth];
+      if (sourceUids.length === 0) {
+        hopResults.push({
+          axbType: hop.axbType,
+          depth,
+          edges: [],
+          sourceCount: 0,
+          truncated: false
+        });
+        continue;
+      }
+      const hopEdges = [];
+      const sourceCount = sourceUids.length;
+      let hopTruncated = false;
+      const tasks = sourceUids.map((uid) => async () => {
+        if (totalReads >= maxReads) {
+          hopTruncated = true;
+          return;
+        }
+        await semaphore.acquire();
+        try {
+          if (totalReads >= maxReads) {
+            hopTruncated = true;
+            return;
+          }
+          totalReads++;
+          const direction2 = hop.direction ?? "forward";
+          const params = { axbType: hop.axbType };
+          if (direction2 === "forward") {
+            params.aUid = uid;
+            if (hop.bType) params.bType = hop.bType;
+          } else {
+            params.bUid = uid;
+            if (hop.aType) params.aType = hop.aType;
+          }
+          if (direction2 === "forward" && hop.aType) {
+            params.aType = hop.aType;
+          }
+          if (direction2 === "reverse" && hop.bType) {
+            params.bType = hop.bType;
+          }
+          if (hop.orderBy) params.orderBy = hop.orderBy;
+          const limit = hop.limit ?? DEFAULT_LIMIT;
+          if (!hop.filter) {
+            params.limit = limit;
+          }
+          let edges = await this.reader.findEdges(params);
+          if (hop.filter) {
+            edges = edges.filter(hop.filter);
+            edges = edges.slice(0, limit);
+          }
+          hopEdges.push(...edges);
+        } finally {
+          semaphore.release();
+        }
+      });
+      await Promise.all(tasks.map((task) => task()));
+      hopResults.push({
+        axbType: hop.axbType,
+        depth,
+        edges: returnIntermediates ? [...hopEdges] : hopEdges,
+        sourceCount,
+        truncated: hopTruncated
+      });
+      if (hopTruncated) {
+        truncated = true;
+      }
+      const direction = hop.direction ?? "forward";
+      sourceUids = [...new Set(
+        hopEdges.map((e) => direction === "forward" ? e.bUid : e.aUid)
+      )];
+    }
+    const lastHop = hopResults[hopResults.length - 1];
+    return {
+      nodes: lastHop.edges,
+      hops: hopResults,
+      totalReads,
+      truncated
+    };
+  }
+};
+function createTraversal(reader, startUid) {
+  return new TraversalBuilderImpl(reader, startUid);
+}
+
+// src/views.ts
+function sanitizeTagPart(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function getCustomElements() {
+  const g = globalThis;
+  if (g.customElements && typeof g.customElements.define === "function") {
+    return g.customElements;
+  }
+  return null;
+}
+function resilientView(ViewClass, tagName) {
+  const g = globalThis;
+  if (!g.HTMLElement) return ViewClass;
+  const Base = g.HTMLElement;
+  const Wrapped = class extends ViewClass {
+    connectedCallback() {
+      try {
+        super.connectedCallback?.();
+      } catch (err) {
+        console.warn(`[firegraph] <${tagName}> connectedCallback error:`, err);
+        this._showError(err);
+      }
+    }
+    disconnectedCallback() {
+      try {
+        super.disconnectedCallback?.();
+      } catch (err) {
+        console.warn(`[firegraph] <${tagName}> disconnectedCallback error:`, err);
+      }
+    }
+    set data(v) {
+      try {
+        super.data = v;
+      } catch (err) {
+        console.warn(`[firegraph] <${tagName}> data setter error:`, err);
+        this._showError(err);
+      }
+    }
+    get data() {
+      try {
+        return super.data;
+      } catch {
+        return {};
+      }
+    }
+    _showError(err) {
+      try {
+        this.innerHTML = `<div style="padding:6px;color:#f87171;font-size:11px;font-family:monospace;">View error in &lt;${tagName}&gt;: ${err instanceof Error ? err.message : String(err)}</div>`;
+      } catch {
+      }
+    }
+  };
+  Wrapped.viewName = ViewClass.viewName;
+  Wrapped.description = ViewClass.description;
+  return Wrapped;
+}
+function defineViews(input) {
+  const nodes = {};
+  const edges = {};
+  const registry = getCustomElements();
+  for (const [entityType, config] of Object.entries(input.nodes ?? {})) {
+    const viewMetas = [];
+    for (const ViewClass of config.views) {
+      const tagName = `fg-${sanitizeTagPart(entityType)}-${sanitizeTagPart(ViewClass.viewName)}`;
+      viewMetas.push({
+        tagName,
+        viewName: ViewClass.viewName,
+        description: ViewClass.description
+      });
+      if (registry && !registry.get(tagName)) {
+        registry.define(tagName, resilientView(ViewClass, tagName));
+      }
+    }
+    nodes[entityType] = {
+      views: viewMetas,
+      sampleData: config.sampleData
+    };
+  }
+  for (const [axbType, config] of Object.entries(input.edges ?? {})) {
+    const viewMetas = [];
+    for (const ViewClass of config.views) {
+      const tagName = `fg-edge-${sanitizeTagPart(axbType)}-${sanitizeTagPart(ViewClass.viewName)}`;
+      viewMetas.push({
+        tagName,
+        viewName: ViewClass.viewName,
+        description: ViewClass.description
+      });
+      if (registry && !registry.get(tagName)) {
+        registry.define(tagName, resilientView(ViewClass, tagName));
+      }
+    }
+    edges[axbType] = {
+      views: viewMetas,
+      sampleData: config.sampleData
+    };
+  }
+  return { nodes, edges };
+}
+
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+function resolveView(resolverConfig, availableViewNames, context) {
+  if (!resolverConfig) return "json";
+  const available = new Set(availableViewNames);
+  if (context) {
+    const contextDefault = resolverConfig[context];
+    if (contextDefault && available.has(contextDefault)) {
+      return contextDefault;
+    }
+  }
+  if (resolverConfig.default && available.has(resolverConfig.default)) {
+    return resolverConfig.default;
+  }
+  return "json";
+}
+
+// src/discover.ts
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
+import { createRequire } from "module";
+import { join, resolve } from "path";
+var DiscoveryError = class extends FiregraphError {
+  constructor(message) {
+    super(message, "DISCOVERY_ERROR");
+    this.name = "DiscoveryError";
+  }
+};
+function readJson(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof SyntaxError ? `Invalid JSON in ${filePath}: ${err.message}` : `Cannot read ${filePath}: ${err.message}`;
+    throw new DiscoveryError(msg);
+  }
+}
+function readJsonIfExists(filePath) {
+  if (!existsSync(filePath)) return void 0;
+  return readJson(filePath);
+}
+var SCHEMA_SCRIPT_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
+function loadSchema(dir, entityLabel) {
+  for (const ext of SCHEMA_SCRIPT_EXTENSIONS) {
+    const candidate = join(dir, `schema${ext}`);
+    if (existsSync(candidate)) {
+      return loadSchemaModule(candidate, entityLabel);
+    }
+  }
+  const jsonPath = join(dir, "schema.json");
+  if (existsSync(jsonPath)) {
+    return readJson(jsonPath);
+  }
+  throw new DiscoveryError(
+    `Missing schema for ${entityLabel} in ${dir}. Provide a schema.ts (or .js/.mts/.mjs) or schema.json file.`
+  );
+}
+var _jiti;
+function getJiti() {
+  if (!_jiti) {
+    const base = typeof __filename !== "undefined" ? __filename : import.meta.url;
+    const esmRequire = createRequire(base);
+    const { createJiti } = esmRequire("jiti");
+    _jiti = createJiti(base, { interopDefault: true });
+  }
+  return _jiti;
+}
+function loadSchemaModule(filePath, entityLabel) {
+  try {
+    const jiti = getJiti();
+    const mod = jiti(filePath);
+    const schema = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+    if (!schema || typeof schema !== "object") {
+      throw new DiscoveryError(
+        `Schema file ${filePath} for ${entityLabel} must default-export a JSON Schema object.`
+      );
+    }
+    return schema;
+  } catch (err) {
+    if (err instanceof DiscoveryError) throw err;
+    throw new DiscoveryError(
+      `Failed to load schema module ${filePath} for ${entityLabel}: ${err.message}`
+    );
+  }
+}
+var VIEW_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
+function findViewsFile(dir) {
+  for (const ext of VIEW_EXTENSIONS) {
+    const candidate = join(dir, `views${ext}`);
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function loadNodeEntity(dir, name) {
+  const schema = loadSchema(dir, `node type "${name}"`);
+  const meta = readJsonIfExists(join(dir, "meta.json"));
+  const sampleData = readJsonIfExists(join(dir, "sample.json"));
+  const viewsPath = findViewsFile(dir);
+  return {
+    kind: "node",
+    name,
+    schema,
+    description: meta?.description,
+    titleField: meta?.titleField,
+    subtitleField: meta?.subtitleField,
+    viewDefaults: meta?.viewDefaults,
+    viewsPath,
+    sampleData
+  };
+}
+function loadEdgeEntity(dir, name) {
+  const schema = loadSchema(dir, `edge type "${name}"`);
+  const edgePath = join(dir, "edge.json");
+  if (!existsSync(edgePath)) {
+    throw new DiscoveryError(
+      `Missing edge.json for edge type "${name}" in ${dir}. Edge entities must declare topology (from/to node types).`
+    );
+  }
+  const topology = readJson(edgePath);
+  if (!topology.from) {
+    throw new DiscoveryError(
+      `edge.json for "${name}" is missing required "from" field`
+    );
+  }
+  if (!topology.to) {
+    throw new DiscoveryError(
+      `edge.json for "${name}" is missing required "to" field`
+    );
+  }
+  const meta = readJsonIfExists(join(dir, "meta.json"));
+  const sampleData = readJsonIfExists(join(dir, "sample.json"));
+  const viewsPath = findViewsFile(dir);
+  return {
+    kind: "edge",
+    name,
+    schema,
+    topology,
+    description: meta?.description,
+    titleField: meta?.titleField,
+    subtitleField: meta?.subtitleField,
+    viewDefaults: meta?.viewDefaults,
+    viewsPath,
+    sampleData
+  };
+}
+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
+  };
+}
+export {
+  BOOTSTRAP_ENTRIES,
+  DiscoveryError,
+  DynamicRegistryError,
+  EDGE_TYPE_SCHEMA,
+  EdgeNotFoundError,
+  FiregraphError,
+  InvalidQueryError,
+  META_EDGE_TYPE,
+  META_NODE_TYPE,
+  NODE_TYPE_SCHEMA,
+  NodeNotFoundError,
+  QueryClient,
+  QueryClientError,
+  RegistryViolationError,
+  TraversalError,
+  ValidationError,
+  buildEdgeQueryPlan,
+  buildEdgeRecord,
+  buildNodeQueryPlan,
+  buildNodeRecord,
+  compileSchema,
+  computeEdgeDocId,
+  computeNodeDocId,
+  createBootstrapRegistry,
+  createGraphClient,
+  createRegistry,
+  createRegistryFromGraph,
+  createTraversal,
+  defineConfig,
+  defineViews,
+  discoverEntities,
+  generateDeterministicUid,
+  generateId,
+  generateTypes,
+  jsonSchemaToFieldMeta,
+  resolveView
+};
+//# sourceMappingURL=index.js.map