@utaba/deep-memory 0.5.0 → 0.6.1

package/dist/index.cjs

@@ -49,7 +49,8 @@ __export(src_exports, {
   VocabularyValidationError: () => VocabularyValidationError,
   generateId: () => generateId,
   isValidUuid: () => isValidUuid,
-  matchesPropertyFilters: () => matchesPropertyFilters
+  matchesPropertyFilters: () => matchesPropertyFilters,
+  projectEntity: () => projectEntity
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -956,310 +957,6 @@ function validateTraversalSpec(spec, vocabulary, capabilities) {
   };
 }
 
-// src/relationships/compilers/GremlinCompiler.ts
-var DEFAULT_ESTIMATED_FANOUT_PER_HOP = 10;
-var GremlinCompiler = class {
-  language = "gremlin";
-  compile(spec, _vocabulary) {
-    const parts = [];
-    const params = {};
-    let paramIndex = 0;
-    let estimatedFanOut = 1;
-    const nextParam = (value) => {
-      const name = `p${paramIndex++}`;
-      params[name] = value;
-      return name;
-    };
-    parts.push("g.V()");
-    if (spec.start.entityId) {
-      const p = nextParam(spec.start.entityId);
-      parts.push(`.has('id', ${p})`);
-    } else if (spec.start.entityType) {
-      const p = nextParam(spec.start.entityType);
-      parts.push(`.has('entityType', ${p})`);
-      estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP;
-    }
-    if (spec.start.filter) {
-      for (const f of spec.start.filter) {
-        parts.push(compilePropertyFilter(f, nextParam));
-      }
-    }
-    const steps = spec.steps ?? [];
-    for (const step of steps) {
-      if (step.repeat) {
-        parts.push(compileRepeatStep(step, nextParam));
-        estimatedFanOut *= step.repeat.maxDepth * DEFAULT_ESTIMATED_FANOUT_PER_HOP;
-      } else if (step.relationshipFilter && step.relationshipFilter.length > 0) {
-        parts.push(compileEdgeStep(step, nextParam));
-        estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP;
-      } else {
-        parts.push(compileSimpleStep(step, nextParam));
-        estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP;
-      }
-      if (step.entityTypes && step.entityTypes.length > 0) {
-        const typeParams = step.entityTypes.map((t) => nextParam(t));
-        parts.push(`.has('entityType', within(${typeParams.join(", ")}))`);
-      }
-      if (step.entityFilter) {
-        for (const f of step.entityFilter) {
-          parts.push(compilePropertyFilter(f, nextParam));
-        }
-      }
-    }
-    if (spec.returnMode === "all") {
-    }
-    if (spec.dedup !== false) {
-      parts.push(".dedup()");
-    }
-    const limit = spec.limit ?? 50;
-    const offset = spec.offset ?? 0;
-    const pOffset = nextParam(offset);
-    const pEnd = nextParam(offset + limit);
-    parts.push(`.range(${pOffset}, ${pEnd})`);
-    params["_limit"] = limit;
-    params["_offset"] = offset;
-    if (spec.returnMode === "path") {
-      parts.push(".path()");
-    }
-    if (spec.returnMode !== "path") {
-      parts.push(".valueMap(true)");
-    }
-    return {
-      query: parts.join(""),
-      params,
-      estimatedFanOut: Math.min(estimatedFanOut, 1e4)
-    };
-  }
-};
-function compileSimpleStep(step, nextParam) {
-  const types = step.relationshipTypes;
-  const typeArgs = types ? types.map((t) => nextParam(t)).join(", ") : "";
-  switch (step.direction) {
-    case "out":
-      return types ? `.out(${typeArgs})` : ".out()";
-    case "in":
-      return types ? `.in(${typeArgs})` : ".in()";
-    case "both":
-      return types ? `.both(${typeArgs})` : ".both()";
-  }
-}
-function compileEdgeStep(step, nextParam) {
-  const parts = [];
-  const types = step.relationshipTypes;
-  const typeArgs = types ? types.map((t) => nextParam(t)).join(", ") : "";
-  switch (step.direction) {
-    case "out":
-      parts.push(types ? `.outE(${typeArgs})` : ".outE()");
-      break;
-    case "in":
-      parts.push(types ? `.inE(${typeArgs})` : ".inE()");
-      break;
-    case "both":
-      parts.push(types ? `.bothE(${typeArgs})` : ".bothE()");
-      break;
-  }
-  if (step.relationshipFilter) {
-    for (const f of step.relationshipFilter) {
-      parts.push(compilePropertyFilter(f, nextParam));
-    }
-  }
-  switch (step.direction) {
-    case "out":
-      parts.push(".inV()");
-      break;
-    case "in":
-      parts.push(".outV()");
-      break;
-    case "both":
-      parts.push(".otherV()");
-      break;
-  }
-  return parts.join("");
-}
-function compileRepeatStep(step, nextParam) {
-  const parts = [];
-  const innerStep = step.relationshipFilter?.length ? compileEdgeStep({ ...step, repeat: void 0 }, nextParam) : compileSimpleStep(step, nextParam);
-  if (step.repeat?.emitIntermediates !== false) {
-    parts.push(".emit()");
-  }
-  parts.push(`.repeat(${innerStep.startsWith(".") ? `__${innerStep}` : innerStep})`);
-  if (step.repeat?.until && step.repeat.until.length > 0) {
-    const untilParts = step.repeat.until.map((f) => compilePropertyFilter(f, nextParam));
-    parts.push(`.until(${untilParts.join("")})`);
-  }
-  if (step.repeat?.maxDepth) {
-    const p = nextParam(step.repeat.maxDepth);
-    parts.push(`.times(${p})`);
-  }
-  if (step.repeat?.emitIntermediates === false) {
-    parts.push(".emit()");
-  }
-  return parts.join("");
-}
-function compilePropertyFilter(filter, nextParam) {
-  const key = nextParam(filter.key);
-  switch (filter.operator) {
-    case "eq": {
-      const val = nextParam(filter.value);
-      return `.has(${key}, ${val})`;
-    }
-    case "neq": {
-      const val = nextParam(filter.value);
-      return `.has(${key}, neq(${val}))`;
-    }
-    case "gt": {
-      const val = nextParam(filter.value);
-      return `.has(${key}, gt(${val}))`;
-    }
-    case "gte": {
-      const val = nextParam(filter.value);
-      return `.has(${key}, gte(${val}))`;
-    }
-    case "lt": {
-      const val = nextParam(filter.value);
-      return `.has(${key}, lt(${val}))`;
-    }
-    case "lte": {
-      const val = nextParam(filter.value);
-      return `.has(${key}, lte(${val}))`;
-    }
-    case "contains": {
-      const val = nextParam(filter.value);
-      return `.has(${key}, containing(${val}))`;
-    }
-    case "isNull":
-      return `.hasNot(${key})`;
-    case "isNotNull":
-      return `.has(${key})`;
-  }
-}
-
-// src/relationships/compilers/CypherCompiler.ts
-var DEFAULT_ESTIMATED_FANOUT_PER_HOP2 = 10;
-var CypherCompiler = class {
-  language = "cypher";
-  compile(spec, _vocabulary) {
-    const params = {};
-    let paramIndex = 0;
-    let estimatedFanOut = 1;
-    const whereClauses = [];
-    let nodeIndex = 0;
-    const nextParam = (value) => {
-      const name = `p${paramIndex++}`;
-      params[name] = value;
-      return `$${name}`;
-    };
-    const startNode = `n${nodeIndex++}`;
-    let matchParts = [];
-    if (spec.start.entityId) {
-      matchParts.push(`(${startNode})`);
-      whereClauses.push(`${startNode}.id = ${nextParam(spec.start.entityId)}`);
-    } else if (spec.start.entityType) {
-      matchParts.push(`(${startNode})`);
-      whereClauses.push(`${startNode}.entityType = ${nextParam(spec.start.entityType)}`);
-      estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP2;
-    } else {
-      matchParts.push(`(${startNode})`);
-    }
-    if (spec.start.filter) {
-      for (const f of spec.start.filter) {
-        whereClauses.push(compilePropertyFilterCypher(startNode, f, nextParam));
-      }
-    }
-    let lastNode = startNode;
-    const steps = spec.steps ?? [];
-    for (let i = 0; i < steps.length; i++) {
-      const step = steps[i];
-      const targetNode = `n${nodeIndex++}`;
-      const relAlias = `r${i}`;
-      const relTypes = step.relationshipTypes?.length ? step.relationshipTypes.join("|") : "";
-      const relTypePattern = relTypes ? `:${relTypes}` : "";
-      const depthPattern = step.repeat ? `*1..${step.repeat.maxDepth}` : "";
-      let pattern;
-      switch (step.direction) {
-        case "out":
-          pattern = `-[${relAlias}${relTypePattern}${depthPattern}]->(${targetNode})`;
-          break;
-        case "in":
-          pattern = `<-[${relAlias}${relTypePattern}${depthPattern}]-(${targetNode})`;
-          break;
-        case "both":
-          pattern = `-[${relAlias}${relTypePattern}${depthPattern}]-(${targetNode})`;
-          break;
-      }
-      matchParts.push(pattern);
-      estimatedFanOut *= step.repeat ? step.repeat.maxDepth * DEFAULT_ESTIMATED_FANOUT_PER_HOP2 : DEFAULT_ESTIMATED_FANOUT_PER_HOP2;
-      if (step.entityTypes && step.entityTypes.length > 0) {
-        const typeParam = nextParam(step.entityTypes);
-        whereClauses.push(`${targetNode}.entityType IN ${typeParam}`);
-      }
-      if (step.entityFilter) {
-        for (const f of step.entityFilter) {
-          whereClauses.push(compilePropertyFilterCypher(targetNode, f, nextParam));
-        }
-      }
-      if (step.relationshipFilter) {
-        for (const f of step.relationshipFilter) {
-          whereClauses.push(compilePropertyFilterCypher(relAlias, f, nextParam));
-        }
-      }
-      lastNode = targetNode;
-    }
-    const matchClause = `MATCH ${matchParts[0]}${matchParts.slice(1).join("")}`;
-    const whereClause = whereClauses.length > 0 ? `
-WHERE ${whereClauses.join(" AND ")}` : "";
-    let returnClause;
-    if (spec.returnMode === "path") {
-      const allNodes = Array.from({ length: nodeIndex }, (_, i) => `n${i}`);
-      const allRels = steps.map((_, i) => `r${i}`);
-      returnClause = `RETURN ${[...allNodes, ...allRels].join(", ")}`;
-    } else if (spec.returnMode === "all") {
-      const allNodes = Array.from({ length: nodeIndex }, (_, i) => `n${i}`);
-      returnClause = spec.dedup !== false ? `RETURN DISTINCT ${allNodes.join(", ")}` : `RETURN ${allNodes.join(", ")}`;
-    } else {
-      returnClause = spec.dedup !== false ? `RETURN DISTINCT ${lastNode}` : `RETURN ${lastNode}`;
-    }
-    const offset = spec.offset ?? 0;
-    const limit = spec.limit ?? 50;
-    const skipClause = offset > 0 ? `
-SKIP ${nextParam(offset)}` : "";
-    const limitClause = `
-LIMIT ${nextParam(limit)}`;
-    params["_limit"] = limit;
-    params["_offset"] = offset;
-    const query = `${matchClause}${whereClause}
-${returnClause}${skipClause}${limitClause}`;
-    return {
-      query,
-      params,
-      estimatedFanOut: Math.min(estimatedFanOut, 1e4)
-    };
-  }
-};
-function compilePropertyFilterCypher(nodeAlias, filter, nextParam) {
-  const prop = `${nodeAlias}.${filter.key}`;
-  switch (filter.operator) {
-    case "eq":
-      return `${prop} = ${nextParam(filter.value)}`;
-    case "neq":
-      return `${prop} <> ${nextParam(filter.value)}`;
-    case "gt":
-      return `${prop} > ${nextParam(filter.value)}`;
-    case "gte":
-      return `${prop} >= ${nextParam(filter.value)}`;
-    case "lt":
-      return `${prop} < ${nextParam(filter.value)}`;
-    case "lte":
-      return `${prop} <= ${nextParam(filter.value)}`;
-    case "contains":
-      return `${prop} CONTAINS ${nextParam(filter.value)}`;
-    case "isNull":
-      return `${prop} IS NULL`;
-    case "isNotNull":
-      return `${prop} IS NOT NULL`;
-  }
-}
-
 // src/relationships/PropertyFilterMatcher.ts
 function matchesPropertyFilters(properties, filters) {
   return filters.every((filter) => matchesSingleFilter(properties, filter));
@@ -1792,8 +1489,9 @@ var GraphTraversal = class {
   }
   /**
    * Execute a structured traversal.
-   * Validates the spec, compiles to native query if a provider exists,
-   * falls back to application-level BFS otherwise.
+   * Validates the spec, delegates to the GraphTraversalProvider if one is
+   * registered (the provider owns native compilation), or falls back to
+   * application-level BFS over StorageProvider.
    */
   async traverse(spec) {
     const capabilities = this.graphTraversalProvider?.getCapabilities();
@@ -1808,19 +1506,8 @@ var GraphTraversal = class {
       }
       throw new TraversalValidationError(structErrors.length > 0 ? structErrors : validation.errors);
     }
-    if (this.graphTraversalProvider && vocabulary) {
-      const language = capabilities.nativeQueryLanguage;
-      let compiledQuery;
-      if (language === "gremlin") {
-        const compiler = new GremlinCompiler();
-        const compiled = compiler.compile(spec, vocabulary);
-        compiledQuery = compiled.query;
-      } else if (language === "cypher") {
-        const compiler = new CypherCompiler();
-        const compiled = compiler.compile(spec, vocabulary);
-        compiledQuery = compiled.query;
-      }
-      return this.graphTraversalProvider.traverse(this.repositoryId, spec, compiledQuery);
+    if (this.graphTraversalProvider) {
+      return this.graphTraversalProvider.traverse(this.repositoryId, spec);
     }
     return executeFallbackTraversal(this.repositoryId, this.storage, spec);
   }
@@ -3407,7 +3094,7 @@ var EventBus = class {
 };
 
 // src/portability/RepositoryExporter.ts
-var LIBRARY_VERSION = true ? "0.5.0" : "0.1.0";
+var LIBRARY_VERSION = true ? "0.6.1" : "0.1.0";
 var RepositoryExporter = class {
   storage;
   provenance;
@@ -4201,6 +3888,16 @@ var DeepMemory = class {
     await this.globalEventBus.emit("repository:opened", { repositoryId });
     return repo;
   }
+  /** Get the full stored record for a single repository (including legal, owner, metadata, governance) */
+  async getRepository(repositoryId) {
+    await this.ensureInitialized();
+    this.validateRepositoryId(repositoryId);
+    const storedRepo = await this.storage.getRepository(repositoryId);
+    if (!storedRepo) {
+      throw new RepositoryNotFoundError(repositoryId);
+    }
+    return storedRepo;
+  }
   /** List all repositories */
   async listRepositories(filter) {
     await this.ensureInitialized();
@@ -4373,54 +4070,358 @@ var DeepMemory = class {
       relationshipCount
     });
   }
-  /**
-   * Import a repository from a stream of chunks.
-   * Use for large repositories to avoid loading everything into memory.
-   */
-  async importRepositoryStream(header, chunks, options) {
-    await this.ensureInitialized();
-    const importer = new RepositoryImporter({
-      storage: this.storage,
-      actorId: this.provenance.getContext().actorId,
-      onProgress: (progress) => this.globalEventBus.emit("import:progress", progress)
-    });
-    await this.globalEventBus.emit("import:started", { repositoryId: options.target.repositoryId });
-    const result = await importer.importStream(header, chunks, options);
-    if (result.success) {
-      await this.globalEventBus.emit("import:completed", {
-        repositoryId: result.repositoryId,
-        entitiesImported: result.statistics.entitiesImported,
-        relationshipsImported: result.statistics.relationshipsImported
-      });
-    } else {
-      await this.globalEventBus.emit("import:failed", {
-        repositoryId: result.repositoryId,
-        error: result.warnings.map((w) => w.message).join("; ")
-      });
+  /**
+   * Import a repository from a stream of chunks.
+   * Use for large repositories to avoid loading everything into memory.
+   */
+  async importRepositoryStream(header, chunks, options) {
+    await this.ensureInitialized();
+    const importer = new RepositoryImporter({
+      storage: this.storage,
+      actorId: this.provenance.getContext().actorId,
+      onProgress: (progress) => this.globalEventBus.emit("import:progress", progress)
+    });
+    await this.globalEventBus.emit("import:started", { repositoryId: options.target.repositoryId });
+    const result = await importer.importStream(header, chunks, options);
+    if (result.success) {
+      await this.globalEventBus.emit("import:completed", {
+        repositoryId: result.repositoryId,
+        entitiesImported: result.statistics.entitiesImported,
+        relationshipsImported: result.statistics.relationshipsImported
+      });
+    } else {
+      await this.globalEventBus.emit("import:failed", {
+        repositoryId: result.repositoryId,
+        error: result.warnings.map((w) => w.message).join("; ")
+      });
+    }
+    return result;
+  }
+  /** Subscribe to global events */
+  on(event, handler) {
+    return this.globalEventBus.on(event, handler);
+  }
+  /** Update the provenance context (e.g., new conversation) */
+  updateProvenance(context) {
+    this.provenance.updateContext(context);
+    this.globalEventBus.updateProvenance(this.provenance.getContext());
+  }
+  /** Dispose of all resources */
+  async dispose() {
+    this.globalEventBus.removeAllListeners();
+    if (this.graphTraversalProvider?.dispose) {
+      await this.graphTraversalProvider.dispose();
+    }
+    if (this.storage.dispose) {
+      await this.storage.dispose();
+    }
+    this.initialized = false;
+  }
+};
+
+// src/relationships/compilers/GremlinCompiler.ts
+var DEFAULT_ESTIMATED_FANOUT_PER_HOP = 10;
+var GremlinCompiler = class {
+  language = "gremlin";
+  compile(spec, _vocabulary) {
+    const parts = [];
+    const params = {};
+    let paramIndex = 0;
+    let estimatedFanOut = 1;
+    const nextParam = (value) => {
+      const name = `p${paramIndex++}`;
+      params[name] = value;
+      return name;
+    };
+    parts.push("g.V()");
+    if (spec.start.entityId) {
+      const p = nextParam(spec.start.entityId);
+      parts.push(`.has('id', ${p})`);
+    } else if (spec.start.entityType) {
+      const p = nextParam(spec.start.entityType);
+      parts.push(`.has('entityType', ${p})`);
+      estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP;
+    }
+    if (spec.start.filter) {
+      for (const f of spec.start.filter) {
+        parts.push(compilePropertyFilter(f, nextParam));
+      }
+    }
+    const steps = spec.steps ?? [];
+    for (const step of steps) {
+      if (step.repeat) {
+        parts.push(compileRepeatStep(step, nextParam));
+        estimatedFanOut *= step.repeat.maxDepth * DEFAULT_ESTIMATED_FANOUT_PER_HOP;
+      } else if (step.relationshipFilter && step.relationshipFilter.length > 0) {
+        parts.push(compileEdgeStep(step, nextParam));
+        estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP;
+      } else {
+        parts.push(compileSimpleStep(step, nextParam));
+        estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP;
+      }
+      if (step.entityTypes && step.entityTypes.length > 0) {
+        const typeParams = step.entityTypes.map((t) => nextParam(t));
+        parts.push(`.has('entityType', within(${typeParams.join(", ")}))`);
+      }
+      if (step.entityFilter) {
+        for (const f of step.entityFilter) {
+          parts.push(compilePropertyFilter(f, nextParam));
+        }
+      }
+    }
+    if (spec.returnMode === "all") {
+    }
+    if (spec.dedup !== false) {
+      parts.push(".dedup()");
+    }
+    const limit = spec.limit ?? 50;
+    const offset = spec.offset ?? 0;
+    const pOffset = nextParam(offset);
+    const pEnd = nextParam(offset + limit);
+    parts.push(`.range(${pOffset}, ${pEnd})`);
+    params["_limit"] = limit;
+    params["_offset"] = offset;
+    if (spec.returnMode === "path") {
+      parts.push(".path()");
+    }
+    if (spec.returnMode !== "path") {
+      parts.push(".valueMap(true)");
+    }
+    return {
+      query: parts.join(""),
+      params,
+      estimatedFanOut: Math.min(estimatedFanOut, 1e4)
+    };
+  }
+};
+function compileSimpleStep(step, nextParam) {
+  const types = step.relationshipTypes;
+  const typeArgs = types ? types.map((t) => nextParam(t)).join(", ") : "";
+  switch (step.direction) {
+    case "out":
+      return types ? `.out(${typeArgs})` : ".out()";
+    case "in":
+      return types ? `.in(${typeArgs})` : ".in()";
+    case "both":
+      return types ? `.both(${typeArgs})` : ".both()";
+  }
+}
+function compileEdgeStep(step, nextParam) {
+  const parts = [];
+  const types = step.relationshipTypes;
+  const typeArgs = types ? types.map((t) => nextParam(t)).join(", ") : "";
+  switch (step.direction) {
+    case "out":
+      parts.push(types ? `.outE(${typeArgs})` : ".outE()");
+      break;
+    case "in":
+      parts.push(types ? `.inE(${typeArgs})` : ".inE()");
+      break;
+    case "both":
+      parts.push(types ? `.bothE(${typeArgs})` : ".bothE()");
+      break;
+  }
+  if (step.relationshipFilter) {
+    for (const f of step.relationshipFilter) {
+      parts.push(compilePropertyFilter(f, nextParam));
     }
-    return result;
   }
-  /** Subscribe to global events */
-  on(event, handler) {
-    return this.globalEventBus.on(event, handler);
+  switch (step.direction) {
+    case "out":
+      parts.push(".inV()");
+      break;
+    case "in":
+      parts.push(".outV()");
+      break;
+    case "both":
+      parts.push(".otherV()");
+      break;
   }
-  /** Update the provenance context (e.g., new conversation) */
-  updateProvenance(context) {
-    this.provenance.updateContext(context);
-    this.globalEventBus.updateProvenance(this.provenance.getContext());
+  return parts.join("");
+}
+function compileRepeatStep(step, nextParam) {
+  const parts = [];
+  const innerStep = step.relationshipFilter?.length ? compileEdgeStep({ ...step, repeat: void 0 }, nextParam) : compileSimpleStep(step, nextParam);
+  if (step.repeat?.emitIntermediates !== false) {
+    parts.push(".emit()");
   }
-  /** Dispose of all resources */
-  async dispose() {
-    this.globalEventBus.removeAllListeners();
-    if (this.graphTraversalProvider?.dispose) {
-      await this.graphTraversalProvider.dispose();
+  parts.push(`.repeat(${innerStep.startsWith(".") ? `__${innerStep}` : innerStep})`);
+  if (step.repeat?.until && step.repeat.until.length > 0) {
+    const untilParts = step.repeat.until.map((f) => compilePropertyFilter(f, nextParam));
+    parts.push(`.until(${untilParts.join("")})`);
+  }
+  if (step.repeat?.maxDepth) {
+    const p = nextParam(step.repeat.maxDepth);
+    parts.push(`.times(${p})`);
+  }
+  if (step.repeat?.emitIntermediates === false) {
+    parts.push(".emit()");
+  }
+  return parts.join("");
+}
+function compilePropertyFilter(filter, nextParam) {
+  const key = nextParam(filter.key);
+  switch (filter.operator) {
+    case "eq": {
+      const val = nextParam(filter.value);
+      return `.has(${key}, ${val})`;
     }
-    if (this.storage.dispose) {
-      await this.storage.dispose();
+    case "neq": {
+      const val = nextParam(filter.value);
+      return `.has(${key}, neq(${val}))`;
     }
-    this.initialized = false;
+    case "gt": {
+      const val = nextParam(filter.value);
+      return `.has(${key}, gt(${val}))`;
+    }
+    case "gte": {
+      const val = nextParam(filter.value);
+      return `.has(${key}, gte(${val}))`;
+    }
+    case "lt": {
+      const val = nextParam(filter.value);
+      return `.has(${key}, lt(${val}))`;
+    }
+    case "lte": {
+      const val = nextParam(filter.value);
+      return `.has(${key}, lte(${val}))`;
+    }
+    case "contains": {
+      const val = nextParam(filter.value);
+      return `.has(${key}, containing(${val}))`;
+    }
+    case "isNull":
+      return `.hasNot(${key})`;
+    case "isNotNull":
+      return `.has(${key})`;
+  }
+}
+
+// src/relationships/compilers/CypherCompiler.ts
+var DEFAULT_ESTIMATED_FANOUT_PER_HOP2 = 10;
+var CypherCompiler = class {
+  language = "cypher";
+  compile(spec, _vocabulary) {
+    const params = {};
+    let paramIndex = 0;
+    let estimatedFanOut = 1;
+    const whereClauses = [];
+    let nodeIndex = 0;
+    const nextParam = (value) => {
+      const name = `p${paramIndex++}`;
+      params[name] = value;
+      return `$${name}`;
+    };
+    const startNode = `n${nodeIndex++}`;
+    let matchParts = [];
+    if (spec.start.entityId) {
+      matchParts.push(`(${startNode})`);
+      whereClauses.push(`${startNode}.id = ${nextParam(spec.start.entityId)}`);
+    } else if (spec.start.entityType) {
+      matchParts.push(`(${startNode})`);
+      whereClauses.push(`${startNode}.entityType = ${nextParam(spec.start.entityType)}`);
+      estimatedFanOut *= DEFAULT_ESTIMATED_FANOUT_PER_HOP2;
+    } else {
+      matchParts.push(`(${startNode})`);
+    }
+    if (spec.start.filter) {
+      for (const f of spec.start.filter) {
+        whereClauses.push(compilePropertyFilterCypher(startNode, f, nextParam));
+      }
+    }
+    let lastNode = startNode;
+    const steps = spec.steps ?? [];
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      const targetNode = `n${nodeIndex++}`;
+      const relAlias = `r${i}`;
+      const relTypes = step.relationshipTypes?.length ? step.relationshipTypes.join("|") : "";
+      const relTypePattern = relTypes ? `:${relTypes}` : "";
+      const depthPattern = step.repeat ? `*1..${step.repeat.maxDepth}` : "";
+      let pattern;
+      switch (step.direction) {
+        case "out":
+          pattern = `-[${relAlias}${relTypePattern}${depthPattern}]->(${targetNode})`;
+          break;
+        case "in":
+          pattern = `<-[${relAlias}${relTypePattern}${depthPattern}]-(${targetNode})`;
+          break;
+        case "both":
+          pattern = `-[${relAlias}${relTypePattern}${depthPattern}]-(${targetNode})`;
+          break;
+      }
+      matchParts.push(pattern);
+      estimatedFanOut *= step.repeat ? step.repeat.maxDepth * DEFAULT_ESTIMATED_FANOUT_PER_HOP2 : DEFAULT_ESTIMATED_FANOUT_PER_HOP2;
+      if (step.entityTypes && step.entityTypes.length > 0) {
+        const typeParam = nextParam(step.entityTypes);
+        whereClauses.push(`${targetNode}.entityType IN ${typeParam}`);
+      }
+      if (step.entityFilter) {
+        for (const f of step.entityFilter) {
+          whereClauses.push(compilePropertyFilterCypher(targetNode, f, nextParam));
+        }
+      }
+      if (step.relationshipFilter) {
+        for (const f of step.relationshipFilter) {
+          whereClauses.push(compilePropertyFilterCypher(relAlias, f, nextParam));
+        }
+      }
+      lastNode = targetNode;
+    }
+    const matchClause = `MATCH ${matchParts[0]}${matchParts.slice(1).join("")}`;
+    const whereClause = whereClauses.length > 0 ? `
+WHERE ${whereClauses.join(" AND ")}` : "";
+    let returnClause;
+    if (spec.returnMode === "path") {
+      const allNodes = Array.from({ length: nodeIndex }, (_, i) => `n${i}`);
+      const allRels = steps.map((_, i) => `r${i}`);
+      returnClause = `RETURN ${[...allNodes, ...allRels].join(", ")}`;
+    } else if (spec.returnMode === "all") {
+      const allNodes = Array.from({ length: nodeIndex }, (_, i) => `n${i}`);
+      returnClause = spec.dedup !== false ? `RETURN DISTINCT ${allNodes.join(", ")}` : `RETURN ${allNodes.join(", ")}`;
+    } else {
+      returnClause = spec.dedup !== false ? `RETURN DISTINCT ${lastNode}` : `RETURN ${lastNode}`;
+    }
+    const offset = spec.offset ?? 0;
+    const limit = spec.limit ?? 50;
+    const skipClause = offset > 0 ? `
+SKIP ${nextParam(offset)}` : "";
+    const limitClause = `
+LIMIT ${nextParam(limit)}`;
+    params["_limit"] = limit;
+    params["_offset"] = offset;
+    const query = `${matchClause}${whereClause}
+${returnClause}${skipClause}${limitClause}`;
+    return {
+      query,
+      params,
+      estimatedFanOut: Math.min(estimatedFanOut, 1e4)
+    };
   }
 };
+function compilePropertyFilterCypher(nodeAlias, filter, nextParam) {
+  const prop = `${nodeAlias}.${filter.key}`;
+  switch (filter.operator) {
+    case "eq":
+      return `${prop} = ${nextParam(filter.value)}`;
+    case "neq":
+      return `${prop} <> ${nextParam(filter.value)}`;
+    case "gt":
+      return `${prop} > ${nextParam(filter.value)}`;
+    case "gte":
+      return `${prop} >= ${nextParam(filter.value)}`;
+    case "lt":
+      return `${prop} < ${nextParam(filter.value)}`;
+    case "lte":
+      return `${prop} <= ${nextParam(filter.value)}`;
+    case "contains":
+      return `${prop} CONTAINS ${nextParam(filter.value)}`;
+    case "isNull":
+      return `${prop} IS NULL`;
+    case "isNotNull":
+      return `${prop} IS NOT NULL`;
+  }
+}
 
 // src/providers-builtin/InMemoryStorageProvider.ts
 var InMemoryStorageProvider = class {
@@ -5155,6 +5156,7 @@ var NoOpEmbeddingProvider = class {
   VocabularyValidationError,
   generateId,
   isValidUuid,
-  matchesPropertyFilters
+  matchesPropertyFilters,
+  projectEntity
 });
 //# sourceMappingURL=index.cjs.map