@nicia-ai/typegraph 0.13.0 → 0.15.0

package/dist/index.cjs

@@ -1,16 +1,66 @@
 'use strict';
 
-var chunk7VITUTRA_cjs = require('./chunk-7VITUTRA.cjs');
+var chunk3HQLOKS5_cjs = require('./chunk-3HQLOKS5.cjs');
 var chunkNI2GV74U_cjs = require('./chunk-NI2GV74U.cjs');
 var chunk44SXEVF4_cjs = require('./chunk-44SXEVF4.cjs');
-var chunk2WVFEIHR_cjs = require('./chunk-2WVFEIHR.cjs');
+var chunkMME3H4ZF_cjs = require('./chunk-MME3H4ZF.cjs');
 var chunkP5CNM325_cjs = require('./chunk-P5CNM325.cjs');
 var zod = require('zod');
 var drizzleOrm = require('drizzle-orm');
 var nanoid = require('nanoid');
 
+// src/store/reserved-keys.ts
+var RESERVED_NODE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "meta"
+]);
+var RESERVED_EDGE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "meta",
+  "fromKind",
+  "fromId",
+  "toKind",
+  "toId"
+]);
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function validateProjectionField(field2, entityType, kind) {
+  const reserved = entityType === "node" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;
+  if (reserved.has(field2)) {
+    throw new chunk44SXEVF4_cjs.ConfigurationError(
+      `Projection field "${field2}" on ${entityType} kind "${kind}" conflicts with a reserved structural key`,
+      { field: field2, kind, entityType, reservedKeys: [...reserved] },
+      {
+        suggestion: `Remove "${field2}" from the projection. Structural fields (${[...reserved].join(", ")}) are included automatically when relevant.`
+      }
+    );
+  }
+  if (PROTOTYPE_POLLUTION_KEYS.has(field2)) {
+    throw new chunk44SXEVF4_cjs.ConfigurationError(
+      `Projection field "${field2}" on ${entityType} kind "${kind}" is not allowed`,
+      { field: field2, kind, entityType },
+      {
+        suggestion: `"${field2}" cannot be used as a projection field name.`
+      }
+    );
+  }
+}
+function filterReservedKeys(props, reservedKeys) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (!reservedKeys.has(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+
 // src/core/node.ts
-var RESERVED_NODE_KEYS = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
 function validateSchemaKeys(schema, name) {
   const shape = schema.shape;
   const conflicts = Object.keys(shape).filter(
@@ -35,15 +85,6 @@ function defineNode(name, options) {
     description: options.description
   });
 }
-var RESERVED_EDGE_KEYS = /* @__PURE__ */ new Set([
-  "id",
-  "kind",
-  "meta",
-  "fromKind",
-  "fromId",
-  "toKind",
-  "toId"
-]);
 var EMPTY_SCHEMA = zod.z.object({});
 function validateSchemaKeys2(schema, name) {
   const shape = schema.shape;
@@ -84,7 +125,7 @@ function metaEdge(name, options = {}) {
     description: options.description
   };
   return Object.freeze({
-    [chunk7VITUTRA_cjs.META_EDGE_BRAND]: true,
+    [chunk3HQLOKS5_cjs.META_EDGE_BRAND]: true,
     name,
     properties
   });
@@ -120,7 +161,7 @@ function createExternalRef(table) {
 // src/ontology/core-meta-edges.ts
 function createMetaEdge(name, properties) {
   return Object.freeze({
-    [chunk7VITUTRA_cjs.META_EDGE_BRAND]: true,
+    [chunk3HQLOKS5_cjs.META_EDGE_BRAND]: true,
     name,
     properties: {
       transitive: properties.transitive ?? false,
@@ -132,7 +173,7 @@ function createMetaEdge(name, properties) {
     }
   });
 }
-var subClassOfMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_SUB_CLASS_OF, {
+var subClassOfMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_SUB_CLASS_OF, {
   transitive: true,
   inference: "subsumption",
   description: "Type inheritance (Podcast subClassOf Media)"
@@ -144,9 +185,9 @@ function subClassOf(child, parent) {
     to: parent
   };
 }
-var broaderMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_BROADER, {
+var broaderMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_BROADER, {
   transitive: true,
-  inverse: chunk7VITUTRA_cjs.META_EDGE_NARROWER,
+  inverse: chunk3HQLOKS5_cjs.META_EDGE_NARROWER,
   inference: "hierarchy",
   description: "Broader concept (ML broader AI)"
 });
@@ -157,9 +198,9 @@ function broader(narrowerConcept, broaderConcept) {
     to: broaderConcept
   };
 }
-var narrowerMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_NARROWER, {
+var narrowerMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_NARROWER, {
   transitive: true,
-  inverse: chunk7VITUTRA_cjs.META_EDGE_BROADER,
+  inverse: chunk3HQLOKS5_cjs.META_EDGE_BROADER,
   inference: "hierarchy",
   description: "Narrower concept (AI narrower ML)"
 });
@@ -170,7 +211,7 @@ function narrower(broaderConcept, narrowerConcept) {
     to: narrowerConcept
   };
 }
-var relatedToMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_RELATED_TO, {
+var relatedToMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_RELATED_TO, {
   symmetric: true,
   inference: "association",
   description: "Non-hierarchical association"
@@ -182,7 +223,7 @@ function relatedTo(conceptA, conceptB) {
     to: conceptB
   };
 }
-var equivalentToMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_EQUIVALENT_TO, {
+var equivalentToMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_EQUIVALENT_TO, {
   symmetric: true,
   transitive: true,
   inference: "substitution",
@@ -195,7 +236,7 @@ function equivalentTo(kindA, kindBOrIri) {
     to: kindBOrIri
   };
 }
-var sameAsMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_SAME_AS, {
+var sameAsMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_SAME_AS, {
   symmetric: true,
   transitive: true,
   inference: "substitution",
@@ -208,7 +249,7 @@ function sameAs(kindA, kindBOrIri) {
     to: kindBOrIri
   };
 }
-var differentFromMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_DIFFERENT_FROM, {
+var differentFromMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_DIFFERENT_FROM, {
   symmetric: true,
   inference: "constraint",
   description: "Explicitly different individuals"
@@ -220,7 +261,7 @@ function differentFrom(kindA, kindB) {
     to: kindB
   };
 }
-var disjointWithMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_DISJOINT_WITH, {
+var disjointWithMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_DISJOINT_WITH, {
   symmetric: true,
   inference: "constraint",
   description: "Mutually exclusive types"
@@ -232,9 +273,9 @@ function disjointWith(kindA, kindB) {
     to: kindB
   };
 }
-var partOfMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_PART_OF, {
+var partOfMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_PART_OF, {
   transitive: true,
-  inverse: chunk7VITUTRA_cjs.META_EDGE_HAS_PART,
+  inverse: chunk3HQLOKS5_cjs.META_EDGE_HAS_PART,
   inference: "composition",
   description: "X is part of Y"
 });
@@ -245,9 +286,9 @@ function partOf(part, whole) {
     to: whole
   };
 }
-var hasPartMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_HAS_PART, {
+var hasPartMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_HAS_PART, {
   transitive: true,
-  inverse: chunk7VITUTRA_cjs.META_EDGE_PART_OF,
+  inverse: chunk3HQLOKS5_cjs.META_EDGE_PART_OF,
   inference: "composition",
   description: "Y has part X"
 });
@@ -258,12 +299,12 @@ function hasPart(whole, part) {
     to: part
   };
 }
-var inverseOfMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_INVERSE_OF, {
+var inverseOfMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_INVERSE_OF, {
   symmetric: true,
   inference: "none",
   description: "Edge A is inverse of edge B"
 });
-var impliesMetaEdge = createMetaEdge(chunk7VITUTRA_cjs.META_EDGE_IMPLIES, {
+var impliesMetaEdge = createMetaEdge(chunk3HQLOKS5_cjs.META_EDGE_IMPLIES, {
   transitive: true,
   inference: "none",
   description: "Edge A implies edge B exists"
@@ -1374,14 +1415,14 @@ function extractVectorSimilarityPredicates(predicates) {
         break;
       }
       case "and": {
-        for (const p of expr.predicates) {
-          visit(p, inDisallowedBranch);
+        for (const predicate2 of expr.predicates) {
+          visit(predicate2, inDisallowedBranch);
         }
         break;
       }
       case "or": {
-        for (const p of expr.predicates) {
-          visit(p, true);
+        for (const predicate2 of expr.predicates) {
+          visit(predicate2, true);
         }
         break;
       }
@@ -2404,6 +2445,9 @@ function compileTemporalFilter(options) {
       return drizzleOrm.sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;
     }
     case "asOf": {
+      if (asOf === void 0) {
+        throw new Error(`asOf timestamp is required for temporal mode "asOf"`);
+      }
       const timestamp = asOf;
       return drizzleOrm.sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
     }
@@ -2714,7 +2758,7 @@ function lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlan
   }
   const vectorPredicate = runVectorPredicatePass(
     query,
-    chunk2WVFEIHR_cjs.getDialect(dialect)
+    chunkMME3H4ZF_cjs.getDialect(dialect)
   ).vectorPredicate;
   const effectiveLimit = resolveVectorAwareLimit(query.limit, vectorPredicate);
   const loweringInput = {
@@ -2811,7 +2855,7 @@ function lowerSetOperationToLogicalPlan(input) {
 }
 
 // src/query/compiler/recursive.ts
-var MAX_RECURSIVE_DEPTH = 100;
+var MAX_RECURSIVE_DEPTH = 10;
 var MAX_EXPLICIT_RECURSIVE_DEPTH = 1e3;
 var NO_ALWAYS_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
 function runRecursiveQueryPassPipeline(ast, graphId, ctx) {
@@ -3304,15 +3348,14 @@ var DEFAULT_TABLE_NAMES = {
   edges: "typegraph_edges",
   embeddings: "typegraph_node_embeddings"
 };
-var MAX_IDENTIFIER_LENGTH = 63;
 var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
 function validateTableName(name, label) {
   if (!name || name.length === 0) {
     throw new chunk44SXEVF4_cjs.ConfigurationError(`${label} table name cannot be empty`);
   }
-  if (name.length > MAX_IDENTIFIER_LENGTH) {
+  if (name.length > chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH) {
     throw new chunk44SXEVF4_cjs.ConfigurationError(
-      `${label} table name exceeds maximum length of ${MAX_IDENTIFIER_LENGTH} characters`
+      `${label} table name exceeds maximum length of ${chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
     );
   }
   if (!VALID_IDENTIFIER_PATTERN.test(name)) {
@@ -3395,64 +3438,13 @@ function decodeByValueType(value, valueType) {
   }
 }
 
-// src/store/reserved-keys.ts
-var RESERVED_NODE_KEYS2 = /* @__PURE__ */ new Set([
-  "id",
-  "kind",
-  "meta"
-]);
-var RESERVED_EDGE_KEYS2 = /* @__PURE__ */ new Set([
-  "id",
-  "kind",
-  "meta",
-  "fromKind",
-  "fromId",
-  "toKind",
-  "toId"
-]);
-var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype"
-]);
-function validateProjectionField(field2, entityType, kind) {
-  const reserved = entityType === "node" ? RESERVED_NODE_KEYS2 : RESERVED_EDGE_KEYS2;
-  if (reserved.has(field2)) {
-    throw new chunk44SXEVF4_cjs.ConfigurationError(
-      `Projection field "${field2}" on ${entityType} kind "${kind}" conflicts with a reserved structural key`,
-      { field: field2, kind, entityType, reservedKeys: [...reserved] },
-      {
-        suggestion: `Remove "${field2}" from the projection. Structural fields (${[...reserved].join(", ")}) are included automatically when relevant.`
-      }
-    );
-  }
-  if (PROTOTYPE_POLLUTION_KEYS.has(field2)) {
-    throw new chunk44SXEVF4_cjs.ConfigurationError(
-      `Projection field "${field2}" on ${entityType} kind "${kind}" is not allowed`,
-      { field: field2, kind, entityType },
-      {
-        suggestion: `"${field2}" cannot be used as a projection field name.`
-      }
-    );
-  }
-}
-function filterReservedKeys(props, reservedKeys) {
-  const filtered = {};
-  for (const [key, value] of Object.entries(props)) {
-    if (!reservedKeys.has(key)) {
-      filtered[key] = value;
-    }
-  }
-  return filtered;
-}
-
 // src/store/row-mappers.ts
 function nullToUndefined2(value) {
   return value === null ? void 0 : value;
 }
 function rowToNode(row) {
   const rawProps = JSON.parse(row.props);
-  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS2);
+  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS);
   return {
     kind: row.kind,
     id: row.id,
@@ -3472,7 +3464,7 @@ function rowToNodeMeta(row) {
 }
 function rowToEdge(row) {
   const rawProps = JSON.parse(row.props);
-  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS2);
+  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS);
   return {
     id: row.id,
     kind: row.kind,
@@ -3496,17 +3488,6 @@ function rowToEdgeMeta(row) {
 
 // src/store/subgraph.ts
 var DEFAULT_SUBGRAPH_MAX_DEPTH = 10;
-var MAX_PG_IDENTIFIER_LENGTH = 63;
-function fnv1aBase36(input) {
-  let hash = 2166136261;
-  for (const character of input) {
-    const codePoint = character.codePointAt(0);
-    if (codePoint === void 0) continue;
-    hash ^= codePoint;
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
 var TEXT_ENCODER = new TextEncoder();
 function truncateToBytes(value, maxBytes) {
   const encoded = TEXT_ENCODER.encode(value);
@@ -3519,9 +3500,9 @@ function truncateToBytes(value, maxBytes) {
 }
 function projectionAlias(entityPrefix, kind, field2) {
   const prefix = entityPrefix === "node" ? "sg_n" : "sg_e";
-  const hash = fnv1aBase36(`${kind}\0${field2}`);
+  const hash = chunkMME3H4ZF_cjs.fnv1aBase36(`${kind}\0${field2}`);
   const fixedBytes = prefix.length + 1 + 1 + hash.length;
-  const maxKindBytes = MAX_PG_IDENTIFIER_LENGTH - fixedBytes;
+  const maxKindBytes = chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH - fixedBytes;
   const truncatedKind = truncateToBytes(kind, maxKindBytes);
   return `${prefix}_${truncatedKind}_${hash}`;
 }
@@ -3538,7 +3519,7 @@ async function executeSubgraph(params) {
   }
   const maxDepth = Math.min(
     options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
-    MAX_RECURSIVE_DEPTH
+    MAX_EXPLICIT_RECURSIVE_DEPTH
   );
   const ctx = {
     graphId: params.graphId,
@@ -4222,6 +4203,7 @@ function compileFieldColumnForSetOp(field2, prefix, dialect) {
       updated_at: "_updated_at",
       deleted_at: "_deleted_at"
     };
+    if (columnName === void 0) return drizzleOrm.sql.raw(`${cteName}.${alias}_props`);
     const suffix = columnMap[columnName];
     if (suffix) {
       return drizzleOrm.sql.raw(`${cteName}.${alias}${suffix}`);
@@ -4300,18 +4282,18 @@ function buildSetOperationSuffixClauses(op, dialect) {
       );
     }
     const orderParts = [];
-    for (const o of op.orderBy) {
-      const projected = matchFieldToProjection(o.field, projection);
+    for (const orderSpec of op.orderBy) {
+      const projected = matchFieldToProjection(orderSpec.field, projection);
       if (!projected) {
-        const fieldDesc = o.field.jsonPointer ? `${o.field.alias}.props${o.field.jsonPointer}` : `${o.field.alias}.${o.field.path.join(".")}`;
+        const fieldDesc = orderSpec.field.jsonPointer ? `${orderSpec.field.alias}.props${orderSpec.field.jsonPointer}` : `${orderSpec.field.alias}.${orderSpec.field.path.join(".")}`;
         const availableFields = projection.fields.map((f) => f.outputName).join(", ");
         throw new chunk44SXEVF4_cjs.UnsupportedPredicateError(
           `Set operation ORDER BY field "${fieldDesc}" is not in the projection. ORDER BY for UNION/INTERSECT/EXCEPT must reference projected columns. Available columns: ${availableFields}`
         );
       }
       const columnRef = drizzleOrm.sql.raw(dialect.quoteIdentifier(projected.outputName));
-      const dir = drizzleOrm.sql.raw(o.direction.toUpperCase());
-      const nulls = o.nulls ?? (o.direction === "asc" ? "last" : "first");
+      const dir = drizzleOrm.sql.raw(orderSpec.direction.toUpperCase());
+      const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
       const nullsDir = drizzleOrm.sql.raw(nulls === "first" ? "DESC" : "ASC");
       orderParts.push(
         drizzleOrm.sql`(${columnRef} IS NULL) ${nullsDir}`,
@@ -4663,7 +4645,7 @@ function compileQuery(ast, graphId, options = "sqlite") {
   const options_ = typeof options === "string" ? { dialect: options } : options;
   const dialect = options_.dialect ?? "sqlite";
   const schema = options_.schema ?? DEFAULT_SQL_SCHEMA;
-  const adapter = chunk2WVFEIHR_cjs.getDialect(dialect);
+  const adapter = chunkMME3H4ZF_cjs.getDialect(dialect);
   const ctx = {
     dialect: adapter,
     schema,
@@ -4703,7 +4685,7 @@ function compileSetOperation2(op, graphId, options = "sqlite") {
   const options_ = typeof options === "string" ? { dialect: options } : options;
   const dialect = options_.dialect ?? "sqlite";
   const schema = options_.schema ?? DEFAULT_SQL_SCHEMA;
-  const adapter = chunk2WVFEIHR_cjs.getDialect(dialect);
+  const adapter = chunkMME3H4ZF_cjs.getDialect(dialect);
   return compileSetOperation(
     op,
     graphId,
@@ -5178,13 +5160,14 @@ function generateId() {
 
 // src/utils/path.ts
 function parseSqlitePath(path) {
-  if (!path || path === "||") return [];
+  const emptyPath = `${chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER}${chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER}`;
+  if (!path || path === emptyPath) return [];
   const trimmed = path.slice(1, -1);
   if (trimmed === "") return [];
-  return trimmed.split("|");
+  return trimmed.split(chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER);
 }
 function isSqlitePath(value) {
-  return typeof value === "string" && value.startsWith("|") && value.endsWith("|");
+  return typeof value === "string" && value.startsWith(chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER) && value.endsWith(chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER);
 }
 function normalizePath(value) {
   if (Array.isArray(value)) {
@@ -5199,20 +5182,20 @@ function normalizePath(value) {
   return [];
 }
 function isPostgresTextArray(value) {
-  return typeof value === "string" && value.startsWith("{") && value.endsWith("}");
+  return typeof value === "string" && value.startsWith(chunkMME3H4ZF_cjs.PG_ARRAY_START) && value.endsWith(chunkMME3H4ZF_cjs.PG_ARRAY_END);
 }
 function parsePostgresTextArray(value) {
   const inner = value.slice(1, -1);
   if (inner === "") return [];
-  return inner.split(",");
+  return inner.split(chunkMME3H4ZF_cjs.PG_PATH_ELEMENT_SEPARATOR);
 }
 
 // src/query/execution/result-mapper.ts
 function transformPathColumns(rows, state, _dialect) {
   const pathAliases = [];
-  for (const t of state.traversals) {
-    if (t.variableLength?.pathAlias !== void 0) {
-      pathAliases.push(t.variableLength.pathAlias);
+  for (const traversal of state.traversals) {
+    if (traversal.variableLength?.pathAlias !== void 0) {
+      pathAliases.push(traversal.variableLength.pathAlias);
     }
   }
   if (pathAliases.length === 0) return rows;
@@ -5236,8 +5219,8 @@ function transformPathColumns(rows, state, _dialect) {
   }
   return changed ? result : rows;
 }
-var RESERVED_NODE_KEYS3 = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
-var RESERVED_EDGE_KEYS3 = /* @__PURE__ */ new Set(["id", "kind", "fromId", "toId", "meta"]);
+var RESERVED_NODE_KEYS2 = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
+var RESERVED_EDGE_KEYS2 = /* @__PURE__ */ new Set(["id", "kind", "fromId", "toId", "meta"]);
 function nullToUndefined3(value) {
   return value === null ? void 0 : value;
 }
@@ -5275,7 +5258,7 @@ function buildSelectableNode(row, alias) {
       deletedAt
     }
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS3);
+  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS2);
   return result;
 }
 function buildSelectableNodeOrUndefined(row, alias) {
@@ -5317,7 +5300,7 @@ function buildSelectableEdge(row, alias) {
       deletedAt
     }
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_EDGE_KEYS3);
+  assignPropsExcludingReserved(result, rawProps, RESERVED_EDGE_KEYS2);
   return result;
 }
 function buildSelectContext(row, startAlias, traversals) {
@@ -5445,7 +5428,7 @@ async function* createStreamIterable(batchSize, paginate) {
   }
 }
 function getStreamBatchSize(options) {
-  return options?.batchSize ?? 1e3;
+  return options?.batchSize ?? chunkMME3H4ZF_cjs.DEFAULT_STREAM_BATCH_SIZE;
 }
 
 // src/query/ast.ts
@@ -5537,7 +5520,7 @@ function createNodeTrackingProxy(alias, kindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunk2WVFEIHR_cjs.NODE_META_KEYS) {
+          for (const key of chunkMME3H4ZF_cjs.NODE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildNodeMetaPlaceholder(options.mode);
@@ -5570,7 +5553,7 @@ function createEdgeTrackingProxy(alias, edgeKindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunk2WVFEIHR_cjs.EDGE_META_KEYS) {
+          for (const key of chunkMME3H4ZF_cjs.EDGE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildEdgeMetaPlaceholder(options.mode);
@@ -5857,6 +5840,9 @@ function buildSelectiveContext(row, plans, traversals) {
   return context;
 }
 function buildOptionalAliasValue(row, plan) {
+  if (plan.idOutputName === void 0) {
+    return void 0;
+  }
   const idValue = row[plan.idOutputName];
   if (idValue === null || idValue === void 0) {
     return void 0;
@@ -6258,7 +6244,7 @@ function substituteParameters(ast, bindings) {
   };
 }
 function fillPlaceholders(params, bindings, dialect) {
-  const adapter = chunk2WVFEIHR_cjs.getDialect(dialect);
+  const adapter = chunkMME3H4ZF_cjs.getDialect(dialect);
   return params.map((parameter) => {
     if (parameter instanceof drizzleOrm.Placeholder) {
       const name = parameter.name;
@@ -7333,7 +7319,7 @@ var ExecutableQuery = class _ExecutableQuery {
       );
     }
     const isBackward = options.last !== void 0 || options.before !== void 0;
-    const limit = options.first ?? options.last ?? 20;
+    const limit = options.first ?? options.last ?? chunkMME3H4ZF_cjs.DEFAULT_PAGINATION_LIMIT;
     const cursor = options.after ?? options.before;
     let cursorData;
     if (cursor) {
@@ -7656,7 +7642,8 @@ var TraversalBuilder = class _TraversalBuilder {
   }
   /**
    * Enables variable-length (recursive) traversal.
-   * By default, traverses unlimited depth with cycle prevention.
+   * Defaults to MAX_RECURSIVE_DEPTH (10) hops with cycle prevention.
+   * Use `maxHops` to override (up to MAX_EXPLICIT_RECURSIVE_DEPTH).
    */
   recursive(options) {
     const minDepth = options?.minHops ?? this.#variableLength.minDepth;
@@ -8850,8 +8837,8 @@ function createQueryBuilder(graphId, registry, options) {
 function buildKindRegistry(graph) {
   const nodeTypes = extractNodeTypes(graph);
   const edgeTypes = extractEdgeTypes(graph);
-  const closures = graph.ontology.length > 0 ? chunk7VITUTRA_cjs.computeClosuresFromOntology(graph.ontology) : chunk7VITUTRA_cjs.createEmptyClosures();
-  return new chunk7VITUTRA_cjs.KindRegistry(nodeTypes, edgeTypes, closures);
+  const closures = graph.ontology.length > 0 ? chunk3HQLOKS5_cjs.computeClosuresFromOntology(graph.ontology) : chunk3HQLOKS5_cjs.createEmptyClosures();
+  return new chunk3HQLOKS5_cjs.KindRegistry(nodeTypes, edgeTypes, closures);
 }
 function extractNodeTypes(graph) {
   const result = /* @__PURE__ */ new Map();
@@ -9604,53 +9591,47 @@ function createNodeCollection(config) {
 // src/store/collection-factory.ts
 function createNodeCollectionsProxy(graph, graphId, registry, backend, operations) {
   const collectionCache = /* @__PURE__ */ new Map();
-  return new Proxy(
-    {},
-    {
-      get: (_, kind) => {
-        if (!(kind in graph.nodes)) {
-          throw new chunk44SXEVF4_cjs.KindNotFoundError(kind, "node");
-        }
-        const cached = collectionCache.get(kind);
-        if (cached !== void 0) {
-          return cached;
-        }
-        const collection = createNodeCollection({
-          graphId,
-          kind,
-          backend,
-          ...operations
-        });
-        collectionCache.set(kind, collection);
-        return collection;
+  return new Proxy({}, {
+    get: (_, kind) => {
+      if (!(kind in graph.nodes)) {
+        throw new chunk44SXEVF4_cjs.KindNotFoundError(kind, "node");
       }
+      const cached = collectionCache.get(kind);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const collection = createNodeCollection({
+        graphId,
+        kind,
+        backend,
+        ...operations
+      });
+      collectionCache.set(kind, collection);
+      return collection;
     }
-  );
+  });
 }
 function createEdgeCollectionsProxy(graph, graphId, registry, backend, operations) {
   const collectionCache = /* @__PURE__ */ new Map();
-  return new Proxy(
-    {},
-    {
-      get: (_, kind) => {
-        if (!(kind in graph.edges)) {
-          throw new chunk44SXEVF4_cjs.KindNotFoundError(kind, "edge");
-        }
-        const cached = collectionCache.get(kind);
-        if (cached !== void 0) {
-          return cached;
-        }
-        const collection = createEdgeCollection({
-          graphId,
-          kind,
-          backend,
-          ...operations
-        });
-        collectionCache.set(kind, collection);
-        return collection;
+  return new Proxy({}, {
+    get: (_, kind) => {
+      if (!(kind in graph.edges)) {
+        throw new chunk44SXEVF4_cjs.KindNotFoundError(kind, "edge");
       }
+      const cached = collectionCache.get(kind);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const collection = createEdgeCollection({
+        graphId,
+        kind,
+        backend,
+        ...operations
+      });
+      collectionCache.set(kind, collection);
+      return collection;
     }
-  );
+  });
 }
 
 // src/constraints/index.ts
@@ -10053,7 +10034,7 @@ async function validateAndPrepareEdgeCreate(ctx, input, id, backend) {
       nodeId: input.toId
     });
   }
-  const validatedProps = chunk7VITUTRA_cjs.validateEdgeProps(edgeKind.schema, input.props, {
+  const validatedProps = chunk3HQLOKS5_cjs.validateEdgeProps(edgeKind.schema, input.props, {
     kind,
     operation: "create"
   });
@@ -10203,7 +10184,7 @@ async function executeEdgeUpdate(ctx, input, backend) {
     const edgeKind = registration.type;
     const existingProps = JSON.parse(existing.props);
     const mergedProps = { ...existingProps, ...input.props };
-    const validatedProps = chunk7VITUTRA_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
+    const validatedProps = chunk3HQLOKS5_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
       kind: existing.kind,
       operation: "update",
       id
@@ -10229,7 +10210,7 @@ async function executeEdgeUpsertUpdate(ctx, input, backend, options) {
   const edgeKind = registration.type;
   const existingProps = JSON.parse(existing.props);
   const mergedProps = { ...existingProps, ...input.props };
-  const validatedProps = chunk7VITUTRA_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
+  const validatedProps = chunk3HQLOKS5_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
     kind: existing.kind,
     operation: "update",
     id
@@ -10386,7 +10367,7 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
   const matchOn = options?.matchOn ?? [];
   const registration = getEdgeRegistration(ctx.graph, kind);
   const edgeKind = registration.type;
-  const validatedProps = chunk7VITUTRA_cjs.validateEdgeProps(edgeKind.schema, props, {
+  const validatedProps = chunk3HQLOKS5_cjs.validateEdgeProps(edgeKind.schema, props, {
     kind,
     operation: "create"
   });
@@ -10430,6 +10411,9 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
     return { edge: edge2, action: "updated" };
   }
   const cardinality = registration.cardinality ?? "many";
+  if (deletedRow === void 0) {
+    throw new Error("Expected deletedRow to be defined");
+  }
   const matchedDeletedRow = deletedRow;
   const effectiveValidTo = matchedDeletedRow.valid_to;
   const constraintContext = {
@@ -10465,7 +10449,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
   validateMatchOnFields(edgeKind.schema, matchOn, kind);
   const validated = [];
   for (const item of items) {
-    const validatedProps = chunk7VITUTRA_cjs.validateEdgeProps(edgeKind.schema, item.props, {
+    const validatedProps = chunk3HQLOKS5_cjs.validateEdgeProps(edgeKind.schema, item.props, {
       kind,
       operation: "create"
     });
@@ -10549,6 +10533,9 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       });
     } else {
       const bestRow = liveRow ?? deletedRow;
+      if (bestRow === void 0) {
+        throw new Error("Expected at least one of liveRow or deletedRow");
+      }
       toFetch.push({
         index,
         row: bestRow,
@@ -10849,11 +10836,12 @@ function getNodeRegistration(graph, kind) {
   if (registration === void 0) throw new chunk44SXEVF4_cjs.KindNotFoundError(kind, "node");
   return registration;
 }
+var CACHE_KEY_SEPARATOR = "\0";
 function buildNodeCacheKey(graphId, kind, id) {
-  return `${graphId}\0${kind}\0${id}`;
+  return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;
 }
 function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
-  return `${graphId}\0${nodeKind}\0${constraintName}\0${key}`;
+  return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;
 }
 function createNodeAlreadyExistsError(kind, id) {
   return new chunk44SXEVF4_cjs.ValidationError(
@@ -10890,6 +10878,23 @@ function createPendingUniqueRow(graphId, nodeKind, constraintName, key, nodeId)
     deleted_at: void 0
   };
 }
+function resolveConstraint(graph, kind, constraintName) {
+  const registration = getNodeRegistration(graph, kind);
+  const constraints = registration.unique ?? [];
+  const constraint = constraints.find(
+    (candidate) => candidate.name === constraintName
+  );
+  if (constraint === void 0) {
+    throw new chunk44SXEVF4_cjs.NodeConstraintNotFoundError(constraintName, kind);
+  }
+  return constraint;
+}
+function createUniquenessContext(graphId, registry, backend) {
+  return { graphId, registry, backend };
+}
+function createEmbeddingSyncContext(graphId, nodeKind, nodeId, backend) {
+  return { graphId, nodeKind, nodeId, backend };
+}
 function createNodeBatchValidationBackend(graphId, registry, backend) {
   const nodeCache = /* @__PURE__ */ new Map();
   const pendingNodes = /* @__PURE__ */ new Map();
@@ -10898,12 +10903,8 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
   async function getNodeCached(lookupGraphId, kind, id) {
     const cacheKey = buildNodeCacheKey(lookupGraphId, kind, id);
     const pendingNode = pendingNodes.get(cacheKey);
-    if (pendingNode !== void 0) {
-      return pendingNode;
-    }
-    if (nodeCache.has(cacheKey)) {
-      return nodeCache.get(cacheKey);
-    }
+    if (pendingNode !== void 0) return pendingNode;
+    if (nodeCache.has(cacheKey)) return nodeCache.get(cacheKey);
     const existing = await backend.getNode(lookupGraphId, kind, id);
     nodeCache.set(cacheKey, existing);
     return existing;
@@ -10925,16 +10926,14 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
         pendingOwner
       );
     }
-    if (uniqueCache.has(cacheKey)) {
-      return uniqueCache.get(cacheKey);
-    }
+    if (uniqueCache.has(cacheKey)) return uniqueCache.get(cacheKey);
     const existing = await backend.checkUnique(params);
     uniqueCache.set(cacheKey, existing);
     return existing;
   }
   function registerPendingNode(params) {
     const cacheKey = buildNodeCacheKey(params.graphId, params.kind, params.id);
-    const pendingNode = {
+    pendingNodes.set(cacheKey, {
       graph_id: params.graphId,
       kind: params.kind,
       id: params.id,
@@ -10945,14 +10944,11 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
       created_at: "",
       updated_at: "",
       deleted_at: void 0
-    };
-    pendingNodes.set(cacheKey, pendingNode);
+    });
   }
   function registerPendingUniqueEntries(kind, id, props, constraints) {
     for (const constraint of constraints) {
-      if (!checkWherePredicate(constraint, props)) {
-        continue;
-      }
+      if (!checkWherePredicate(constraint, props)) continue;
       const key = computeUniqueKey(
         props,
         constraint.fields,
@@ -10998,7 +10994,7 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend) {
   const kind = input.kind;
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunk7VITUTRA_cjs.validateNodeProps(nodeKind.schema, input.props, {
+  const validatedProps = chunk3HQLOKS5_cjs.validateNodeProps(nodeKind.schema, input.props, {
     kind,
     operation: "create"
   });
@@ -11014,14 +11010,9 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend) {
     backend
   };
   await checkDisjointnessConstraint(constraintContext, kind, id);
-  const uniquenessContext = {
-    graphId: ctx.graphId,
-    registry: ctx.registry,
-    backend
-  };
   const uniqueConstraints = registration.unique ?? [];
   await checkUniquenessConstraints(
-    uniquenessContext,
+    createUniquenessContext(ctx.graphId, ctx.registry, backend),
     kind,
     id,
     validatedProps,
@@ -11044,77 +11035,112 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend) {
   };
 }
 async function finalizeNodeCreate(ctx, prepared, backend) {
-  const uniquenessContext = {
-    graphId: ctx.graphId,
-    registry: ctx.registry,
-    backend
-  };
   await insertUniquenessEntries(
-    uniquenessContext,
+    createUniquenessContext(ctx.graphId, ctx.registry, backend),
     prepared.kind,
     prepared.id,
     prepared.validatedProps,
     prepared.uniqueConstraints
   );
-  const embeddingSyncContext = {
-    graphId: ctx.graphId,
-    nodeKind: prepared.kind,
-    nodeId: prepared.id,
-    backend
-  };
   await syncEmbeddings(
-    embeddingSyncContext,
+    createEmbeddingSyncContext(
+      ctx.graphId,
+      prepared.kind,
+      prepared.id,
+      backend
+    ),
     prepared.nodeKind.schema,
     prepared.validatedProps
   );
 }
-async function executeNodeCreateInternal(ctx, input, backend, options) {
-  const kind = input.kind;
-  const id = input.id ?? generateId();
-  const opContext = ctx.createOperationContext("create", "node", kind, id);
-  return ctx.withOperationHooks(opContext, async () => {
+async function performNodeUpdate(ctx, input, backend, options) {
+  const { kind, id } = input;
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const existing = await backend.getNode(ctx.graphId, kind, id);
+  if (!existing || existing.deleted_at && !options?.clearDeleted) {
+    throw new chunk44SXEVF4_cjs.NodeNotFoundError(kind, id);
+  }
+  const existingProps = JSON.parse(existing.props);
+  const mergedProps = { ...existingProps, ...input.props };
+  const nodeKind = registration.type;
+  const validatedProps = chunk3HQLOKS5_cjs.validateNodeProps(nodeKind.schema, mergedProps, {
+    kind,
+    operation: "update",
+    id
+  });
+  const validTo = chunkNI2GV74U_cjs.validateOptionalIsoDate(input.validTo, "validTo");
+  await updateUniquenessEntries(
+    createUniquenessContext(ctx.graphId, ctx.registry, backend),
+    kind,
+    id,
+    existingProps,
+    validatedProps,
+    registration.unique ?? []
+  );
+  const updateParams = {
+    graphId: ctx.graphId,
+    kind,
+    id,
+    props: validatedProps,
+    incrementVersion: true
+  };
+  if (validTo !== void 0) updateParams.validTo = validTo;
+  if (options?.clearDeleted) updateParams.clearDeleted = true;
+  const row = await backend.updateNode(updateParams);
+  await syncEmbeddings(
+    createEmbeddingSyncContext(ctx.graphId, kind, id, backend),
+    nodeKind.schema,
+    validatedProps
+  );
+  return rowToNode(row);
+}
+async function enforceDeleteBehavior(ctx, kind, id, mode, backend, registration) {
+  const deleteBehavior = registration.onDelete ?? "restrict";
+  const connectedEdges = await backend.findEdgesConnectedTo({
+    graphId: ctx.graphId,
+    nodeKind: kind,
+    nodeId: id
+  });
+  if (connectedEdges.length === 0) return;
+  switch (deleteBehavior) {
+    case "restrict": {
+      const edgeKinds = [...new Set(connectedEdges.map((edge) => edge.kind))];
+      throw new chunk44SXEVF4_cjs.RestrictedDeleteError({
+        nodeKind: kind,
+        nodeId: id,
+        edgeCount: connectedEdges.length,
+        edgeKinds
+      });
+    }
+    case "cascade":
+    case "disconnect": {
+      for (const edge of connectedEdges) {
+        await (mode === "hard" ? backend.hardDeleteEdge({
+          graphId: ctx.graphId,
+          id: edge.id
+        }) : backend.deleteEdge({
+          graphId: ctx.graphId,
+          id: edge.id
+        }));
+      }
+      break;
+    }
+  }
+}
+async function prepareBatchCreates(ctx, inputs, backend) {
+  const {
+    backend: validationBackend,
+    registerPendingNode,
+    registerPendingUniqueEntries
+  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
+  const preparedCreates = [];
+  for (const input of inputs) {
+    const id = input.id ?? generateId();
     const prepared = await validateAndPrepareNodeCreate(
       ctx,
       input,
       id,
-      backend
-    );
-    let row;
-    {
-      row = await backend.insertNode(prepared.insertParams);
-    }
-    await finalizeNodeCreate(ctx, prepared, backend);
-    if (row === void 0) return;
-    return rowToNode(row);
-  });
-}
-async function executeNodeCreate(ctx, input, backend) {
-  const result = await executeNodeCreateInternal(ctx, input, backend);
-  if (!result) {
-    throw new chunk44SXEVF4_cjs.DatabaseOperationError(
-      "Node create failed: expected created node row",
-      { operation: "insert", entity: "node" }
-    );
-  }
-  return result;
-}
-async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
-  if (inputs.length === 0) {
-    return;
-  }
-  const {
-    backend: validationBackend,
-    registerPendingNode,
-    registerPendingUniqueEntries
-  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
-  const preparedCreates = [];
-  for (const input of inputs) {
-    const id = input.id ?? generateId();
-    const prepared = await validateAndPrepareNodeCreate(
-      ctx,
-      input,
-      id,
-      validationBackend
+      validationBackend
     );
     preparedCreates.push(prepared);
     registerPendingNode(prepared.insertParams);
@@ -11128,6 +11154,92 @@ async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
   const batchInsertParams = preparedCreates.map(
     (prepared) => prepared.insertParams
   );
+  return { preparedCreates, batchInsertParams };
+}
+async function findUniqueRowAcrossKinds(backend, graphId, constraintName, key, kindsToCheck, includeDeleted) {
+  for (const kindToCheck of kindsToCheck) {
+    const row = await backend.checkUnique({
+      graphId,
+      nodeKind: kindToCheck,
+      constraintName,
+      key,
+      includeDeleted
+    });
+    if (row !== void 0) return row;
+  }
+  return void 0;
+}
+async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uniqueKeys, kindsToCheck, includeDeleted) {
+  const existingByKey = /* @__PURE__ */ new Map();
+  for (const kindToCheck of kindsToCheck) {
+    if (backend.checkUniqueBatch === void 0) {
+      for (const key of uniqueKeys) {
+        if (existingByKey.has(key)) continue;
+        const row = await backend.checkUnique({
+          graphId,
+          nodeKind: kindToCheck,
+          constraintName,
+          key,
+          includeDeleted
+        });
+        if (row !== void 0) {
+          existingByKey.set(row.key, row);
+        }
+      }
+    } else {
+      const rows = await backend.checkUniqueBatch({
+        graphId,
+        nodeKind: kindToCheck,
+        constraintName,
+        keys: uniqueKeys,
+        includeDeleted
+      });
+      for (const row of rows) {
+        if (!existingByKey.has(row.key)) {
+          existingByKey.set(row.key, row);
+        }
+      }
+    }
+  }
+  return existingByKey;
+}
+async function executeNodeCreateInternal(ctx, input, backend, options) {
+  const kind = input.kind;
+  const id = input.id ?? generateId();
+  const opContext = ctx.createOperationContext("create", "node", kind, id);
+  return ctx.withOperationHooks(opContext, async () => {
+    const prepared = await validateAndPrepareNodeCreate(
+      ctx,
+      input,
+      id,
+      backend
+    );
+    let row;
+    {
+      row = await backend.insertNode(prepared.insertParams);
+    }
+    await finalizeNodeCreate(ctx, prepared, backend);
+    if (row === void 0) return;
+    return rowToNode(row);
+  });
+}
+async function executeNodeCreate(ctx, input, backend) {
+  const result = await executeNodeCreateInternal(ctx, input, backend);
+  if (!result) {
+    throw new chunk44SXEVF4_cjs.DatabaseOperationError(
+      "Node create failed: expected created node row",
+      { operation: "insert", entity: "node" }
+    );
+  }
+  return result;
+}
+async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
+  if (inputs.length === 0) return;
+  const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
+    ctx,
+    inputs,
+    backend
+  );
   if (backend.insertNodesBatch === void 0) {
     for (const insertParams of batchInsertParams) {
       await (backend.insertNodeNoReturn?.(insertParams) ?? backend.insertNode(insertParams));
@@ -11140,34 +11252,11 @@ async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
   }
 }
 async function executeNodeCreateBatch(ctx, inputs, backend) {
-  if (inputs.length === 0) {
-    return [];
-  }
-  const {
-    backend: validationBackend,
-    registerPendingNode,
-    registerPendingUniqueEntries
-  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
-  const preparedCreates = [];
-  for (const input of inputs) {
-    const id = input.id ?? generateId();
-    const prepared = await validateAndPrepareNodeCreate(
-      ctx,
-      input,
-      id,
-      validationBackend
-    );
-    preparedCreates.push(prepared);
-    registerPendingNode(prepared.insertParams);
-    registerPendingUniqueEntries(
-      prepared.kind,
-      prepared.id,
-      prepared.validatedProps,
-      prepared.uniqueConstraints
-    );
-  }
-  const batchInsertParams = preparedCreates.map(
-    (prepared) => prepared.insertParams
+  if (inputs.length === 0) return [];
+  const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
+    ctx,
+    inputs,
+    backend
   );
   let rows;
   if (backend.insertNodesBatchReturning === void 0) {
@@ -11185,170 +11274,40 @@ async function executeNodeCreateBatch(ctx, inputs, backend) {
   return rows.map((row) => rowToNode(row));
 }
 async function executeNodeUpdate(ctx, input, backend, options) {
-  const kind = input.kind;
-  const id = input.id;
-  const opContext = ctx.createOperationContext("update", "node", kind, id);
-  return ctx.withOperationHooks(opContext, async () => {
-    const registration = getNodeRegistration(ctx.graph, kind);
-    const existing = await backend.getNode(ctx.graphId, kind, id);
-    if (!existing || existing.deleted_at && !options?.clearDeleted) {
-      throw new chunk44SXEVF4_cjs.NodeNotFoundError(kind, id);
-    }
-    const existingProps = JSON.parse(existing.props);
-    const mergedProps = { ...existingProps, ...input.props };
-    const nodeKind = registration.type;
-    const validatedProps = chunk7VITUTRA_cjs.validateNodeProps(nodeKind.schema, mergedProps, {
-      kind,
-      operation: "update",
-      id
-    });
-    const validTo = chunkNI2GV74U_cjs.validateOptionalIsoDate(input.validTo, "validTo");
-    const uniquenessContext = {
-      graphId: ctx.graphId,
-      registry: ctx.registry,
-      backend
-    };
-    await updateUniquenessEntries(
-      uniquenessContext,
-      kind,
-      id,
-      existingProps,
-      validatedProps,
-      registration.unique ?? []
-    );
-    const updateParams = {
-      graphId: ctx.graphId,
-      kind,
-      id,
-      props: validatedProps,
-      incrementVersion: true
-    };
-    if (validTo !== void 0) updateParams.validTo = validTo;
-    if (options?.clearDeleted) updateParams.clearDeleted = true;
-    const row = await backend.updateNode(updateParams);
-    const embeddingSyncContext = {
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      nodeId: id,
-      backend
-    };
-    await syncEmbeddings(embeddingSyncContext, nodeKind.schema, validatedProps);
-    return rowToNode(row);
-  });
+  const opContext = ctx.createOperationContext(
+    "update",
+    "node",
+    input.kind,
+    input.id
+  );
+  return ctx.withOperationHooks(
+    opContext,
+    () => performNodeUpdate(ctx, input, backend, options)
+  );
 }
 async function executeNodeUpsertUpdate(ctx, input, backend, options) {
-  const kind = input.kind;
-  const id = input.id;
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const existing = await backend.getNode(ctx.graphId, kind, id);
-  if (!existing || existing.deleted_at && !options?.clearDeleted) {
-    throw new chunk44SXEVF4_cjs.NodeNotFoundError(kind, id);
-  }
-  const existingProps = JSON.parse(existing.props);
-  const mergedProps = { ...existingProps, ...input.props };
-  const nodeKind = registration.type;
-  const validatedProps = chunk7VITUTRA_cjs.validateNodeProps(nodeKind.schema, mergedProps, {
-    kind,
-    operation: "update",
-    id
-  });
-  const validTo = chunkNI2GV74U_cjs.validateOptionalIsoDate(input.validTo, "validTo");
-  const uniquenessContext = {
-    graphId: ctx.graphId,
-    registry: ctx.registry,
-    backend
-  };
-  await updateUniquenessEntries(
-    uniquenessContext,
-    kind,
-    id,
-    existingProps,
-    validatedProps,
-    registration.unique ?? []
-  );
-  const updateParams = {
-    graphId: ctx.graphId,
-    kind,
-    id,
-    props: validatedProps,
-    incrementVersion: true
-  };
-  if (validTo !== void 0) updateParams.validTo = validTo;
-  if (options?.clearDeleted) updateParams.clearDeleted = true;
-  const row = await backend.updateNode(updateParams);
-  const embeddingSyncContext = {
-    graphId: ctx.graphId,
-    nodeKind: kind,
-    nodeId: id,
-    backend
-  };
-  await syncEmbeddings(embeddingSyncContext, nodeKind.schema, validatedProps);
-  return rowToNode(row);
+  return performNodeUpdate(ctx, input, backend, options);
 }
 async function executeNodeDelete(ctx, kind, id, backend) {
   const opContext = ctx.createOperationContext("delete", "node", kind, id);
   return ctx.withOperationHooks(opContext, async () => {
     const registration = getNodeRegistration(ctx.graph, kind);
     const existing = await backend.getNode(ctx.graphId, kind, id);
-    if (!existing || existing.deleted_at) {
-      return;
-    }
+    if (!existing || existing.deleted_at) return;
     const existingProps = JSON.parse(existing.props);
-    const deleteBehavior = registration.onDelete ?? "restrict";
-    const connectedEdges = await backend.findEdgesConnectedTo({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      nodeId: id
-    });
-    if (connectedEdges.length > 0) {
-      switch (deleteBehavior) {
-        case "restrict": {
-          const edgeKinds = [
-            ...new Set(connectedEdges.map((edge) => edge.kind))
-          ];
-          throw new chunk44SXEVF4_cjs.RestrictedDeleteError({
-            nodeKind: kind,
-            nodeId: id,
-            edgeCount: connectedEdges.length,
-            edgeKinds
-          });
-        }
-        case "cascade":
-        case "disconnect": {
-          for (const edge of connectedEdges) {
-            await backend.deleteEdge({
-              graphId: ctx.graphId,
-              id: edge.id
-            });
-          }
-          break;
-        }
-      }
-    }
-    await backend.deleteNode({
-      graphId: ctx.graphId,
-      kind,
-      id
-    });
-    const uniquenessContext = {
-      graphId: ctx.graphId,
-      registry: ctx.registry,
-      backend
-    };
+    await enforceDeleteBehavior(ctx, kind, id, "soft", backend, registration);
+    await backend.deleteNode({ graphId: ctx.graphId, kind, id });
     await deleteUniquenessEntries(
-      uniquenessContext,
+      createUniquenessContext(ctx.graphId, ctx.registry, backend),
       kind,
       existingProps,
       registration.unique ?? []
     );
     const nodeKind = registration.type;
-    const embeddingSyncContext = {
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      nodeId: id,
-      backend
-    };
-    await deleteNodeEmbeddings(embeddingSyncContext, nodeKind.schema);
+    await deleteNodeEmbeddings(
+      createEmbeddingSyncContext(ctx.graphId, kind, id, backend),
+      nodeKind.schema
+    );
   });
 }
 async function executeNodeHardDelete(ctx, kind, id, backend) {
@@ -11356,71 +11315,29 @@ async function executeNodeHardDelete(ctx, kind, id, backend) {
   return ctx.withOperationHooks(opContext, async () => {
     const registration = getNodeRegistration(ctx.graph, kind);
     const existing = await backend.getNode(ctx.graphId, kind, id);
-    if (!existing) {
-      return;
-    }
-    const deleteBehavior = registration.onDelete ?? "restrict";
-    const connectedEdges = await backend.findEdgesConnectedTo({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      nodeId: id
-    });
-    if (connectedEdges.length > 0) {
-      switch (deleteBehavior) {
-        case "restrict": {
-          const edgeKinds = [
-            ...new Set(connectedEdges.map((edge) => edge.kind))
-          ];
-          throw new chunk44SXEVF4_cjs.RestrictedDeleteError({
-            nodeKind: kind,
-            nodeId: id,
-            edgeCount: connectedEdges.length,
-            edgeKinds
-          });
-        }
-        case "cascade":
-        case "disconnect": {
-          for (const edge of connectedEdges) {
-            await backend.hardDeleteEdge({
-              graphId: ctx.graphId,
-              id: edge.id
-            });
-          }
-          break;
-        }
-      }
-    }
+    if (!existing) return;
+    await enforceDeleteBehavior(ctx, kind, id, "hard", backend, registration);
     const hardDelete = async (target) => {
-      await target.hardDeleteNode({
-        graphId: ctx.graphId,
-        kind,
-        id
-      });
+      await target.hardDeleteNode({ graphId: ctx.graphId, kind, id });
     };
     await ("transaction" in backend && backend.capabilities.transactions ? backend.transaction(async (tx) => hardDelete(tx)) : hardDelete(backend));
   });
 }
-function resolveConstraint(graph, kind, constraintName) {
-  const registration = getNodeRegistration(graph, kind);
-  const constraints = registration.unique ?? [];
-  const constraint = constraints.find((c) => c.name === constraintName);
-  if (constraint === void 0) {
-    throw new chunk44SXEVF4_cjs.NodeConstraintNotFoundError(constraintName, kind);
-  }
-  return constraint;
-}
 async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, props, backend, options) {
   const ifExists = options?.ifExists ?? "return";
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunk7VITUTRA_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunk3HQLOKS5_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
   if (!checkWherePredicate(constraint, validatedProps)) {
-    const input = { kind, props: validatedProps };
-    const node = await executeNodeCreate(ctx, input, backend);
+    const node = await executeNodeCreate(
+      ctx,
+      { kind, props: validatedProps },
+      backend
+    );
     return { node, action: "created" };
   }
   const key = computeUniqueKey(
@@ -11433,23 +11350,20 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
     constraint.scope,
     ctx.registry
   );
-  let existingUniqueRow;
-  for (const kindToCheck of kindsToCheck) {
-    const row = await backend.checkUnique({
-      graphId: ctx.graphId,
-      nodeKind: kindToCheck,
-      constraintName: constraint.name,
-      key,
-      includeDeleted: true
-    });
-    if (row !== void 0) {
-      existingUniqueRow = row;
-      break;
-    }
-  }
+  const existingUniqueRow = await findUniqueRowAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    key,
+    kindsToCheck,
+    true
+  );
   if (existingUniqueRow === void 0) {
-    const input = { kind, props: validatedProps };
-    const node = await executeNodeCreate(ctx, input, backend);
+    const node = await executeNodeCreate(
+      ctx,
+      { kind, props: validatedProps },
+      backend
+    );
     return { node, action: "created" };
   }
   const existingRow = await backend.getNode(
@@ -11458,8 +11372,11 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
     existingUniqueRow.node_id
   );
   if (existingRow === void 0) {
-    const input = { kind, props: validatedProps };
-    const node = await executeNodeCreate(ctx, input, backend);
+    const node = await executeNodeCreate(
+      ctx,
+      { kind, props: validatedProps },
+      backend
+    );
     return { node, action: "created" };
   }
   const isSoftDeleted = existingRow.deleted_at !== void 0;
@@ -11482,7 +11399,7 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
 async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunk7VITUTRA_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunk3HQLOKS5_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
@@ -11498,20 +11415,14 @@ async function executeNodeFindByConstraint(ctx, kind, constraintName, props, bac
     constraint.scope,
     ctx.registry
   );
-  let existingUniqueRow;
-  for (const kindToCheck of kindsToCheck) {
-    const row = await backend.checkUnique({
-      graphId: ctx.graphId,
-      nodeKind: kindToCheck,
-      constraintName: constraint.name,
-      key,
-      includeDeleted: false
-    });
-    if (row !== void 0) {
-      existingUniqueRow = row;
-      break;
-    }
-  }
+  const existingUniqueRow = await findUniqueRowAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    key,
+    kindsToCheck,
+    false
+  );
   if (existingUniqueRow === void 0) return void 0;
   const existingRow = await backend.getNode(
     ctx.graphId,
@@ -11522,14 +11433,10 @@ async function executeNodeFindByConstraint(ctx, kind, constraintName, props, bac
     return void 0;
   return rowToNode(existingRow);
 }
-async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items, backend) {
-  if (items.length === 0) return [];
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+function validateAndComputeKeys(nodeKind, kind, constraint, items) {
   const validated = [];
   for (const item of items) {
-    const validatedProps = chunk7VITUTRA_cjs.validateNodeProps(nodeKind.schema, item.props, {
+    const validatedProps = chunk3HQLOKS5_cjs.validateNodeProps(nodeKind.schema, item.props, {
       kind,
       operation: "create"
     });
@@ -11541,49 +11448,35 @@ async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items,
     ) : void 0;
     validated.push({ validatedProps, key });
   }
-  const uniqueKeys = [
+  return validated;
+}
+function collectUniqueKeys(validated) {
+  return [
     ...new Set(
-      validated.map((v) => v.key).filter((k) => k !== void 0)
+      validated.map((entry) => entry.key).filter((key) => key !== void 0)
     )
   ];
+}
+async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items, backend) {
+  if (items.length === 0) return [];
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
+  const uniqueKeys = collectUniqueKeys(validated);
   const kindsToCheck = getKindsForUniquenessCheck(
     kind,
     constraint.scope,
     ctx.registry
   );
-  const existingByKey = /* @__PURE__ */ new Map();
-  if (uniqueKeys.length > 0) {
-    for (const kindToCheck of kindsToCheck) {
-      if (backend.checkUniqueBatch === void 0) {
-        for (const key of uniqueKeys) {
-          if (existingByKey.has(key)) continue;
-          const row = await backend.checkUnique({
-            graphId: ctx.graphId,
-            nodeKind: kindToCheck,
-            constraintName: constraint.name,
-            key,
-            includeDeleted: false
-          });
-          if (row !== void 0) {
-            existingByKey.set(row.key, row);
-          }
-        }
-      } else {
-        const rows = await backend.checkUniqueBatch({
-          graphId: ctx.graphId,
-          nodeKind: kindToCheck,
-          constraintName: constraint.name,
-          keys: uniqueKeys,
-          includeDeleted: false
-        });
-        for (const row of rows) {
-          if (!existingByKey.has(row.key)) {
-            existingByKey.set(row.key, row);
-          }
-        }
-      }
-    }
-  }
+  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    uniqueKeys,
+    kindsToCheck,
+    false
+  ) : /* @__PURE__ */ new Map();
   const results = Array.from({ length: items.length });
   const seenKeys = /* @__PURE__ */ new Map();
   for (const [index, { key }] of validated.entries()) {
@@ -11621,73 +11514,28 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  const validated = [];
-  for (const item of items) {
-    const validatedProps = chunk7VITUTRA_cjs.validateNodeProps(nodeKind.schema, item.props, {
-      kind,
-      operation: "create"
-    });
-    const applies = checkWherePredicate(constraint, validatedProps);
-    const key = applies ? computeUniqueKey(
-      validatedProps,
-      constraint.fields,
-      constraint.collation
-    ) : void 0;
-    validated.push({ validatedProps, key });
-  }
-  const uniqueKeys = [
-    ...new Set(
-      validated.map((v) => v.key).filter((k) => k !== void 0)
-    )
-  ];
+  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
+  const uniqueKeys = collectUniqueKeys(validated);
   const kindsToCheck = getKindsForUniquenessCheck(
     kind,
     constraint.scope,
     ctx.registry
   );
-  const existingByKey = /* @__PURE__ */ new Map();
-  if (uniqueKeys.length > 0) {
-    for (const kindToCheck of kindsToCheck) {
-      if (backend.checkUniqueBatch === void 0) {
-        for (const key of uniqueKeys) {
-          if (existingByKey.has(key)) continue;
-          const row = await backend.checkUnique({
-            graphId: ctx.graphId,
-            nodeKind: kindToCheck,
-            constraintName: constraint.name,
-            key,
-            includeDeleted: true
-          });
-          if (row !== void 0) {
-            existingByKey.set(row.key, row);
-          }
-        }
-      } else {
-        const rows = await backend.checkUniqueBatch({
-          graphId: ctx.graphId,
-          nodeKind: kindToCheck,
-          constraintName: constraint.name,
-          keys: uniqueKeys,
-          includeDeleted: true
-        });
-        for (const row of rows) {
-          if (!existingByKey.has(row.key)) {
-            existingByKey.set(row.key, row);
-          }
-        }
-      }
-    }
-  }
+  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    uniqueKeys,
+    kindsToCheck,
+    true
+  ) : /* @__PURE__ */ new Map();
   const toCreate = [];
   const toFetch = [];
   const duplicateOf = [];
   const seenKeys = /* @__PURE__ */ new Map();
   for (const [index, { validatedProps, key }] of validated.entries()) {
     if (key === void 0) {
-      toCreate.push({
-        index,
-        input: { kind, props: validatedProps }
-      });
+      toCreate.push({ index, input: { kind, props: validatedProps } });
       continue;
     }
     const previousIndex = seenKeys.get(key);
@@ -11698,10 +11546,7 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
     seenKeys.set(key, index);
     const existing = existingByKey.get(key);
     if (existing === void 0) {
-      toCreate.push({
-        index,
-        input: { kind, props: validatedProps }
-      });
+      toCreate.push({ index, input: { kind, props: validatedProps } });
     } else {
       toFetch.push({
         index,
@@ -11735,8 +11580,11 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
       nodeId
     );
     if (existingRow === void 0) {
-      const input = { kind, props: validatedProps };
-      const node = await executeNodeCreate(ctx, input, backend);
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend
+      );
       results[index] = { node, action: "created" };
       continue;
     }
@@ -12037,7 +11885,7 @@ var Store = class {
       graphId: this.graphId,
       rootId,
       backend: this.#backend,
-      dialect: chunk2WVFEIHR_cjs.getDialect(this.#backend.dialect),
+      dialect: chunkMME3H4ZF_cjs.getDialect(this.#backend.dialect),
       schema: this.#schema,
       options
     });
@@ -12209,13 +12057,13 @@ function createStore(graph, backend, options) {
 }
 async function createStoreWithSchema(graph, backend, options) {
   const store = createStore(graph, backend, options);
-  const result = await chunk7VITUTRA_cjs.ensureSchema(backend, graph, options);
+  const result = await chunk3HQLOKS5_cjs.ensureSchema(backend, graph, options);
   return [store, result];
 }
 
 Object.defineProperty(exports, "isMetaEdge", {
   enumerable: true,
-  get: function () { return chunk7VITUTRA_cjs.isMetaEdge; }
+  get: function () { return chunk3HQLOKS5_cjs.isMetaEdge; }
 });
 Object.defineProperty(exports, "defineGraph", {
   enumerable: true,