@typicalday/firegraph 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1953 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BOOTSTRAP_ENTRIES: () => BOOTSTRAP_ENTRIES,
+  DiscoveryError: () => DiscoveryError,
+  DynamicRegistryError: () => DynamicRegistryError,
+  EDGE_TYPE_SCHEMA: () => EDGE_TYPE_SCHEMA,
+  EdgeNotFoundError: () => EdgeNotFoundError,
+  FiregraphError: () => FiregraphError,
+  InvalidQueryError: () => InvalidQueryError,
+  META_EDGE_TYPE: () => META_EDGE_TYPE,
+  META_NODE_TYPE: () => META_NODE_TYPE,
+  NODE_TYPE_SCHEMA: () => NODE_TYPE_SCHEMA,
+  NodeNotFoundError: () => NodeNotFoundError,
+  QueryClient: () => QueryClient,
+  QueryClientError: () => QueryClientError,
+  RegistryViolationError: () => RegistryViolationError,
+  TraversalError: () => TraversalError,
+  ValidationError: () => ValidationError,
+  buildEdgeQueryPlan: () => buildEdgeQueryPlan,
+  buildEdgeRecord: () => buildEdgeRecord,
+  buildNodeQueryPlan: () => buildNodeQueryPlan,
+  buildNodeRecord: () => buildNodeRecord,
+  compileSchema: () => compileSchema,
+  computeEdgeDocId: () => computeEdgeDocId,
+  computeNodeDocId: () => computeNodeDocId,
+  createBootstrapRegistry: () => createBootstrapRegistry,
+  createGraphClient: () => createGraphClient,
+  createRegistry: () => createRegistry,
+  createRegistryFromGraph: () => createRegistryFromGraph,
+  createTraversal: () => createTraversal,
+  defineConfig: () => defineConfig,
+  defineViews: () => defineViews,
+  discoverEntities: () => discoverEntities,
+  generateDeterministicUid: () => generateDeterministicUid,
+  generateId: () => generateId,
+  generateTypes: () => generateTypes,
+  jsonSchemaToFieldMeta: () => jsonSchemaToFieldMeta,
+  resolveView: () => resolveView
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_firestore4 = require("@google-cloud/firestore");
+
+// src/docid.ts
+var import_node_crypto = require("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 = (0, import_node_crypto.createHash)("sha256").update(composite).digest("hex");
+  const shard = hash[0];
+  return `${shard}${SHARD_SEPARATOR}${aUid}${SHARD_SEPARATOR}${axbType}${SHARD_SEPARATOR}${bUid}`;
+}
+
+// src/record.ts
+var import_firestore = require("@google-cloud/firestore");
+function buildNodeRecord(aType, uid, data) {
+  const now = import_firestore.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 = import_firestore.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
+var import_firestore2 = require("@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: import_firestore2.FieldValue.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
+var import_firestore3 = require("@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: import_firestore3.FieldValue.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
+var import_node_crypto2 = require("crypto");
+
+// src/json-schema.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var ajv = new import_ajv.default({ 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 = (0, import_node_crypto2.createHash)("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: import_firestore4.FieldValue.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
+var import_nanoid = require("nanoid");
+function generateId() {
+  return (0, import_nanoid.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
+var import_node_fs = require("fs");
+var import_node_module = require("module");
+var import_node_path = require("path");
+var import_meta = {};
+var DiscoveryError = class extends FiregraphError {
+  constructor(message) {
+    super(message, "DISCOVERY_ERROR");
+    this.name = "DiscoveryError";
+  }
+};
+function readJson(filePath) {
+  try {
+    const raw = (0, import_node_fs.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 (!(0, import_node_fs.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 = (0, import_node_path.join)(dir, `schema${ext}`);
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      return loadSchemaModule(candidate, entityLabel);
+    }
+  }
+  const jsonPath = (0, import_node_path.join)(dir, "schema.json");
+  if ((0, import_node_fs.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 = (0, import_node_module.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 = (0, import_node_path.join)(dir, `views${ext}`);
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+  }
+  return void 0;
+}
+function loadNodeEntity(dir, name) {
+  const schema = loadSchema(dir, `node type "${name}"`);
+  const meta = readJsonIfExists((0, import_node_path.join)(dir, "meta.json"));
+  const sampleData = readJsonIfExists((0, import_node_path.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 = (0, import_node_path.join)(dir, "edge.json");
+  if (!(0, import_node_fs.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((0, import_node_path.join)(dir, "meta.json"));
+  const sampleData = readJsonIfExists((0, import_node_path.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 (!(0, import_node_fs.existsSync)(dir)) return [];
+  return (0, import_node_fs.readdirSync)(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+}
+function discoverEntities(entitiesDir) {
+  const absDir = (0, import_node_path.resolve)(entitiesDir);
+  if (!(0, import_node_fs.existsSync)(absDir) || !(0, import_node_fs.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 = (0, import_node_path.join)(absDir, "nodes");
+  for (const name of getSubdirectories(nodesDir)) {
+    nodes.set(name, loadNodeEntity((0, import_node_path.join)(nodesDir, name), name));
+  }
+  const edgesDir = (0, import_node_path.join)(absDir, "edges");
+  for (const name of getSubdirectories(edgesDir)) {
+    edges.set(name, loadEdgeEntity((0, import_node_path.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/codegen/index.ts
+function pascalCase(s) {
+  return s.replace(
+    /(^|[^a-zA-Z0-9])([a-zA-Z])/g,
+    (_, _sep, ch) => ch.toUpperCase()
+  );
+}
+async function generateTypes(discovery, options = {}) {
+  const { compile } = await import("json-schema-to-typescript");
+  const { banner = true } = options;
+  const chunks = [];
+  if (banner) {
+    chunks.push(
+      "// Auto-generated by firegraph codegen \u2014 do not edit manually\n"
+    );
+  }
+  const sortedNodes = [...discovery.nodes.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const sortedEdges = [...discovery.edges.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  for (const [name, entity] of sortedNodes) {
+    const typeName = `${pascalCase(name)}Data`;
+    const ts = await compile(entity.schema, typeName, {
+      bannerComment: "",
+      additionalProperties: false
+    });
+    chunks.push(ts.trim());
+    chunks.push("");
+  }
+  for (const [name, entity] of sortedEdges) {
+    const typeName = `${pascalCase(name)}EdgeData`;
+    const ts = await compile(entity.schema, typeName, {
+      bannerComment: "",
+      additionalProperties: false
+    });
+    chunks.push(ts.trim());
+    chunks.push("");
+  }
+  return chunks.join("\n").trimEnd() + "\n";
+}
+
+// src/query-client/client.ts
+var import_node_http = __toESM(require("http"), 1);
+
+// src/query-client/shaping.ts
+function summarizeRecord(r) {
+  if (!r) return null;
+  const out = { type: r.aType, uid: r.aUid };
+  const data = r.data;
+  if (data && typeof data === "object" && Object.keys(data).length > 0) {
+    out.data = data;
+  }
+  return out;
+}
+function summarizeEdge(r) {
+  if (!r) return null;
+  const out = {
+    fromType: r.aType,
+    fromUid: r.aUid,
+    relation: r.axbType,
+    toType: r.bType,
+    toUid: r.bUid
+  };
+  const data = r.data;
+  if (data && typeof data === "object" && Object.keys(data).length > 0) {
+    out.data = data;
+  }
+  return out;
+}
+
+// src/query-client/config.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var CONFIG_FILES = ["firegraph.config.ts", "firegraph.config.js", "firegraph.config.mjs"];
+var DEFAULT_PORT = 3884;
+function readEditorPort(cwd) {
+  const dir = cwd ?? process.cwd();
+  for (const name of CONFIG_FILES) {
+    try {
+      const content = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(dir, name), "utf8");
+      const editorBlock = content.match(/editor\s*:\s*\{[^}]*\}/s)?.[0] ?? "";
+      const portMatch = editorBlock.match(/port\s*:\s*(\d+)/);
+      if (portMatch) return parseInt(portMatch[1], 10);
+    } catch {
+      continue;
+    }
+  }
+  return DEFAULT_PORT;
+}
+
+// src/query-client/client.ts
+var QueryClientError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "QueryClientError";
+  }
+};
+function requireString(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new QueryClientError(`${name} must be a non-empty string`, "VALIDATION_ERROR");
+  }
+}
+function clampInt(value, min, max, fallback) {
+  if (value == null) return fallback;
+  if (!Number.isInteger(value)) {
+    throw new QueryClientError(`limit must be an integer`, "VALIDATION_ERROR");
+  }
+  return Math.max(min, Math.min(max, value));
+}
+function validateSortDir(dir) {
+  if (dir != null && dir !== "asc" && dir !== "desc") {
+    throw new QueryClientError(`sortDir must be 'asc' or 'desc'`, "VALIDATION_ERROR");
+  }
+}
+function httpGet(url) {
+  return new Promise((resolve2, reject) => {
+    import_node_http.default.get(url, (res) => {
+      let body = "";
+      res.on("data", (c) => body += c);
+      res.on("end", () => resolve2(body));
+    }).on("error", (err) => {
+      reject(new QueryClientError(`Connection failed: ${err.message}`, "CONNECTION_FAILED"));
+    });
+  });
+}
+function httpPost(url, payload) {
+  const parsed = new URL(url);
+  return new Promise((resolve2, reject) => {
+    const req = import_node_http.default.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload)
+        }
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (c) => body += c);
+        res.on("end", () => resolve2(body));
+      }
+    );
+    req.on("error", (err) => {
+      reject(new QueryClientError(`Connection failed: ${err.message}`, "CONNECTION_FAILED"));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+function parseTrpcResponse(raw, procedure) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new QueryClientError(
+      `Invalid JSON from ${procedure}: ${raw.slice(0, 200)}`,
+      "SERVER_ERROR"
+    );
+  }
+  if (parsed.error) {
+    const msg = typeof parsed.error === "object" && parsed.error !== null ? parsed.error.message ?? JSON.stringify(parsed.error) : String(parsed.error);
+    throw new QueryClientError(`Server error from ${procedure}: ${msg}`, "SERVER_ERROR");
+  }
+  return parsed.result?.data ?? parsed;
+}
+var QueryClient = class {
+  baseUrl;
+  constructor(options) {
+    const host = options?.host ?? "localhost";
+    const port = options?.port ?? readEditorPort();
+    this.baseUrl = `http://${host}:${port}/api/trpc`;
+  }
+  async query(procedure, input) {
+    const qs = input != null ? `?input=${encodeURIComponent(JSON.stringify(input))}` : "";
+    const url = `${this.baseUrl}/${procedure}${qs}`;
+    const raw = await httpGet(url);
+    return parseTrpcResponse(raw, procedure);
+  }
+  async mutate(procedure, input) {
+    const url = `${this.baseUrl}/${procedure}`;
+    const raw = await httpPost(url, JSON.stringify(input));
+    return parseTrpcResponse(raw, procedure);
+  }
+  // --- Public API ---
+  async getSchema() {
+    const data = await this.query("getSchema");
+    return {
+      nodeTypes: (data.nodeTypes ?? []).map(
+        (t) => typeof t === "object" && t !== null ? t.type : t
+      ),
+      edgeTypes: (data.edgeTypes ?? []).map((t) => {
+        const e = t;
+        return {
+          relation: e.axbType,
+          from: e.aType,
+          to: e.bType,
+          inverseLabel: e.inverseLabel ?? null
+        };
+      })
+    };
+  }
+  async getNodeDetail(input) {
+    requireString(input.uid, "uid");
+    const data = await this.query("getNodeDetail", { uid: input.uid });
+    return {
+      node: summarizeRecord(data.node),
+      outEdges: (data.outEdges ?? []).map(summarizeEdge).filter(Boolean),
+      inEdges: (data.inEdges ?? []).map(summarizeEdge).filter(Boolean)
+    };
+  }
+  async getNodes(input) {
+    const limit = clampInt(input.limit, 1, 200, 25);
+    validateSortDir(input.sortDir);
+    const data = await this.query("getNodes", {
+      type: input.type,
+      limit,
+      startAfter: input.startAfter,
+      sortBy: input.sortBy,
+      sortDir: input.sortDir,
+      where: input.where
+    });
+    return {
+      nodes: (data.nodes ?? []).map(summarizeRecord).filter(Boolean),
+      hasMore: data.hasMore ?? false,
+      nextCursor: data.nextCursor
+    };
+  }
+  async getEdges(input) {
+    const hasFilter = input.aType || input.aUid || input.axbType || input.bType || input.bUid || input.where && input.where.length > 0;
+    if (!hasFilter) {
+      throw new QueryClientError(
+        "getEdges requires at least one filter field (aType, aUid, axbType, bType, bUid, or where)",
+        "VALIDATION_ERROR"
+      );
+    }
+    const limit = clampInt(input.limit, 1, 200, 25);
+    validateSortDir(input.sortDir);
+    const data = await this.query("getEdges", {
+      aType: input.aType,
+      aUid: input.aUid,
+      axbType: input.axbType,
+      bType: input.bType,
+      bUid: input.bUid,
+      limit,
+      startAfter: input.startAfter,
+      sortBy: input.sortBy,
+      sortDir: input.sortDir,
+      where: input.where
+    });
+    return {
+      edges: (data.edges ?? []).map(summarizeEdge).filter(Boolean),
+      hasMore: data.hasMore ?? false,
+      nextCursor: data.nextCursor
+    };
+  }
+  async traverse(input) {
+    requireString(input.startUid, "startUid");
+    if (!input.hops || input.hops.length === 0) {
+      throw new QueryClientError("traverse requires at least one hop", "VALIDATION_ERROR");
+    }
+    for (let i = 0; i < input.hops.length; i++) {
+      const hop = input.hops[i];
+      requireString(hop.axbType, `hops[${i}].axbType`);
+      if (hop.direction != null && hop.direction !== "forward" && hop.direction !== "reverse") {
+        throw new QueryClientError(
+          `hops[${i}].direction must be 'forward' or 'reverse'`,
+          "VALIDATION_ERROR"
+        );
+      }
+      if (hop.limit != null && (!Number.isInteger(hop.limit) || hop.limit < 1)) {
+        throw new QueryClientError(
+          `hops[${i}].limit must be a positive integer`,
+          "VALIDATION_ERROR"
+        );
+      }
+    }
+    if (input.maxReads != null && (!Number.isInteger(input.maxReads) || input.maxReads < 1)) {
+      throw new QueryClientError("maxReads must be a positive integer", "VALIDATION_ERROR");
+    }
+    if (input.concurrency != null && (!Number.isInteger(input.concurrency) || input.concurrency < 1)) {
+      throw new QueryClientError("concurrency must be a positive integer", "VALIDATION_ERROR");
+    }
+    const data = await this.mutate("traverse", input);
+    return {
+      hops: (data.hops ?? []).map((h) => ({
+        relation: h.axbType,
+        direction: h.direction,
+        depth: h.depth,
+        edgeCount: (h.edges ?? []).length,
+        edges: (h.edges ?? []).map(summarizeEdge).filter(Boolean),
+        truncated: h.truncated ?? false
+      })),
+      totalReads: data.totalReads ?? 0,
+      truncated: data.truncated ?? false
+    };
+  }
+  async search(input) {
+    requireString(input.q, "q");
+    const limit = clampInt(input.limit, 1, 50, 20);
+    const data = await this.query("search", { q: input.q, limit });
+    return {
+      results: (data.results ?? []).map((r) => {
+        const base = summarizeRecord(r);
+        if (!base) return null;
+        return {
+          ...base,
+          matchType: r._matchType ?? null
+        };
+      }).filter(Boolean)
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs.map