@nicia-ai/typegraph 0.13.0 → 0.14.0

package/dist/index.js

@@ -1,18 +1,68 @@
-import { META_EDGE_BRAND, META_EDGE_SUB_CLASS_OF, META_EDGE_NARROWER, META_EDGE_BROADER, META_EDGE_RELATED_TO, META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS, META_EDGE_DIFFERENT_FROM, META_EDGE_DISJOINT_WITH, META_EDGE_HAS_PART, META_EDGE_PART_OF, META_EDGE_INVERSE_OF, META_EDGE_IMPLIES, ensureSchema, computeClosuresFromOntology, createEmptyClosures, KindRegistry, validateNodeProps, validateEdgeProps } from './chunk-PYV4ADC6.js';
-export { isMetaEdge } from './chunk-PYV4ADC6.js';
+import { META_EDGE_BRAND, META_EDGE_SUB_CLASS_OF, META_EDGE_NARROWER, META_EDGE_BROADER, META_EDGE_RELATED_TO, META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS, META_EDGE_DIFFERENT_FROM, META_EDGE_DISJOINT_WITH, META_EDGE_HAS_PART, META_EDGE_PART_OF, META_EDGE_INVERSE_OF, META_EDGE_IMPLIES, ensureSchema, computeClosuresFromOntology, createEmptyClosures, KindRegistry, validateNodeProps, validateEdgeProps } from './chunk-KLOSTZDQ.js';
+export { isMetaEdge } from './chunk-KLOSTZDQ.js';
 import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, nowIso, validateOptionalIsoDate, getNodeKinds, getEdgeKinds } from './chunk-IRFD3MEU.js';
 export { defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from './chunk-IRFD3MEU.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, CompilerInvariantError, KindNotFoundError, RestrictedDeleteError, NodeNotFoundError, DatabaseOperationError, EdgeNotFoundError, NodeConstraintNotFoundError, UniquenessError, EndpointNotFoundError, CardinalityError, EndpointError, DisjointError } from './chunk-SJ2QMDXY.js';
+import { ConfigurationError, UnsupportedPredicateError, ValidationError, CompilerInvariantError, KindNotFoundError, DatabaseOperationError, EdgeNotFoundError, NodeConstraintNotFoundError, RestrictedDeleteError, NodeNotFoundError, EndpointNotFoundError, UniquenessError, CardinalityError, EndpointError, DisjointError } from './chunk-SJ2QMDXY.js';
 export { CardinalityError, CompilerInvariantError, ConfigurationError, DatabaseOperationError, DisjointError, EdgeNotFoundError, EndpointError, EndpointNotFoundError, KindNotFoundError, MigrationError, NodeConstraintNotFoundError, NodeNotFoundError, RestrictedDeleteError, SchemaMismatchError, TypeGraphError, UniquenessError, UnsupportedPredicateError, ValidationError, VersionConflictError, getErrorSuggestion, isConstraintError, isSystemError, isTypeGraphError, isUserRecoverable } from './chunk-SJ2QMDXY.js';
-import { getDialect, NODE_META_KEYS, EDGE_META_KEYS } from './chunk-54WJF3DW.js';
+import { MAX_PG_IDENTIFIER_LENGTH, DEFAULT_PAGINATION_LIMIT, getDialect, DEFAULT_STREAM_BATCH_SIZE, NODE_META_KEYS, EDGE_META_KEYS, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, fnv1aBase36 } from './chunk-GNIYZKBI.js';
 import { jsonPointer, parseJsonPointer, createSchemaIntrospector, normalizeJsonPointer, joinJsonPointers, resolveFieldTypeInfoAtJsonPointer, getEmbeddingDimensions, isEmbeddingSchema } from './chunk-K7SQ3SWP.js';
 export { MAX_JSON_POINTER_DEPTH, embedding, getEmbeddingDimensions, isEmbeddingSchema, joinJsonPointers, jsonPointer, normalizeJsonPointer, parseJsonPointer } from './chunk-K7SQ3SWP.js';
 import { z } from 'zod';
 import { sql, Placeholder } from 'drizzle-orm';
 import { nanoid } from '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 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 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(
@@ -37,15 +87,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 = z.object({});
 function validateSchemaKeys2(schema, name) {
   const shape = schema.shape;
@@ -1376,14 +1417,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;
       }
@@ -2406,6 +2447,9 @@ function compileTemporalFilter(options) {
       return 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 sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;
     }
@@ -2813,7 +2857,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) {
@@ -3306,15 +3350,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 ConfigurationError(`${label} table name cannot be empty`);
   }
-  if (name.length > MAX_IDENTIFIER_LENGTH) {
+  if (name.length > MAX_PG_IDENTIFIER_LENGTH) {
     throw new ConfigurationError(
-      `${label} table name exceeds maximum length of ${MAX_IDENTIFIER_LENGTH} characters`
+      `${label} table name exceeds maximum length of ${MAX_PG_IDENTIFIER_LENGTH} characters`
     );
   }
   if (!VALID_IDENTIFIER_PATTERN.test(name)) {
@@ -3397,64 +3440,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 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 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,
@@ -3474,7 +3466,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,
@@ -3498,17 +3490,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);
@@ -3540,7 +3521,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,
@@ -4224,6 +4205,7 @@ function compileFieldColumnForSetOp(field2, prefix, dialect) {
       updated_at: "_updated_at",
       deleted_at: "_deleted_at"
     };
+    if (columnName === void 0) return sql.raw(`${cteName}.${alias}_props`);
     const suffix = columnMap[columnName];
     if (suffix) {
       return sql.raw(`${cteName}.${alias}${suffix}`);
@@ -4302,18 +4284,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 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 = sql.raw(dialect.quoteIdentifier(projected.outputName));
-      const dir = sql.raw(o.direction.toUpperCase());
-      const nulls = o.nulls ?? (o.direction === "asc" ? "last" : "first");
+      const dir = sql.raw(orderSpec.direction.toUpperCase());
+      const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
       const nullsDir = sql.raw(nulls === "first" ? "DESC" : "ASC");
       orderParts.push(
         sql`(${columnRef} IS NULL) ${nullsDir}`,
@@ -5180,13 +5162,14 @@ function generateId() {
 
 // src/utils/path.ts
 function parseSqlitePath(path) {
-  if (!path || path === "||") return [];
+  const emptyPath = `${SQLITE_PATH_DELIMITER}${SQLITE_PATH_DELIMITER}`;
+  if (!path || path === emptyPath) return [];
   const trimmed = path.slice(1, -1);
   if (trimmed === "") return [];
-  return trimmed.split("|");
+  return trimmed.split(SQLITE_PATH_DELIMITER);
 }
 function isSqlitePath(value) {
-  return typeof value === "string" && value.startsWith("|") && value.endsWith("|");
+  return typeof value === "string" && value.startsWith(SQLITE_PATH_DELIMITER) && value.endsWith(SQLITE_PATH_DELIMITER);
 }
 function normalizePath(value) {
   if (Array.isArray(value)) {
@@ -5201,20 +5184,20 @@ function normalizePath(value) {
   return [];
 }
 function isPostgresTextArray(value) {
-  return typeof value === "string" && value.startsWith("{") && value.endsWith("}");
+  return typeof value === "string" && value.startsWith(PG_ARRAY_START) && value.endsWith(PG_ARRAY_END);
 }
 function parsePostgresTextArray(value) {
   const inner = value.slice(1, -1);
   if (inner === "") return [];
-  return inner.split(",");
+  return inner.split(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;
@@ -5238,8 +5221,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;
 }
@@ -5277,7 +5260,7 @@ function buildSelectableNode(row, alias) {
       deletedAt
     }
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS3);
+  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS2);
   return result;
 }
 function buildSelectableNodeOrUndefined(row, alias) {
@@ -5319,7 +5302,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) {
@@ -5447,7 +5430,7 @@ async function* createStreamIterable(batchSize, paginate) {
   }
 }
 function getStreamBatchSize(options) {
-  return options?.batchSize ?? 1e3;
+  return options?.batchSize ?? DEFAULT_STREAM_BATCH_SIZE;
 }
 
 // src/query/ast.ts
@@ -5859,6 +5842,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;
@@ -7335,7 +7321,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 ?? DEFAULT_PAGINATION_LIMIT;
     const cursor = options.after ?? options.before;
     let cursorData;
     if (cursor) {
@@ -7658,7 +7644,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;
@@ -10432,6 +10419,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 = {
@@ -10551,6 +10541,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,
@@ -10851,11 +10844,12 @@ function getNodeRegistration(graph, kind) {
   if (registration === void 0) throw new 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 ValidationError(
@@ -10892,6 +10886,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 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();
@@ -10900,12 +10911,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;
@@ -10927,16 +10934,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,
@@ -10947,14 +10952,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,
@@ -11016,14 +11018,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,
@@ -11046,64 +11043,99 @@ 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 () => {
-    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 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 NodeNotFoundError(kind, id);
+  }
+  const existingProps = JSON.parse(existing.props);
+  const mergedProps = { ...existingProps, ...input.props };
+  const nodeKind = registration.type;
+  const validatedProps = validateNodeProps(nodeKind.schema, mergedProps, {
+    kind,
+    operation: "update",
+    id
   });
+  const validTo = 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 executeNodeCreate(ctx, input, backend) {
-  const result = await executeNodeCreateInternal(ctx, input, backend);
-  if (!result) {
-    throw new DatabaseOperationError(
-      "Node create failed: expected created node row",
-      { operation: "insert", entity: "node" }
-    );
+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 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;
+    }
   }
-  return result;
 }
-async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
-  if (inputs.length === 0) {
-    return;
-  }
+async function prepareBatchCreates(ctx, inputs, backend) {
   const {
     backend: validationBackend,
     registerPendingNode,
@@ -11130,46 +11162,109 @@ async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
   const batchInsertParams = preparedCreates.map(
     (prepared) => prepared.insertParams
   );
-  if (backend.insertNodesBatch === void 0) {
-    for (const insertParams of batchInsertParams) {
-      await (backend.insertNodeNoReturn?.(insertParams) ?? backend.insertNode(insertParams));
-    }
-  } else {
-    await backend.insertNodesBatch(batchInsertParams);
-  }
-  for (const prepared of preparedCreates) {
-    await finalizeNodeCreate(ctx, prepared, backend);
-  }
+  return { preparedCreates, batchInsertParams };
 }
-async function executeNodeCreateBatch(ctx, inputs, backend) {
-  if (inputs.length === 0) {
-    return [];
+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;
   }
-  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,
+  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,
-      validationBackend
+      backend
     );
-    preparedCreates.push(prepared);
-    registerPendingNode(prepared.insertParams);
-    registerPendingUniqueEntries(
-      prepared.kind,
-      prepared.id,
-      prepared.validatedProps,
-      prepared.uniqueConstraints
+    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 DatabaseOperationError(
+      "Node create failed: expected created node row",
+      { operation: "insert", entity: "node" }
     );
   }
-  const batchInsertParams = preparedCreates.map(
-    (prepared) => prepared.insertParams
+  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));
+    }
+  } else {
+    await backend.insertNodesBatch(batchInsertParams);
+  }
+  for (const prepared of preparedCreates) {
+    await finalizeNodeCreate(ctx, prepared, backend);
+  }
+}
+async function executeNodeCreateBatch(ctx, inputs, backend) {
+  if (inputs.length === 0) return [];
+  const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
+    ctx,
+    inputs,
+    backend
   );
   let rows;
   if (backend.insertNodesBatchReturning === void 0) {
@@ -11187,170 +11282,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 NodeNotFoundError(kind, id);
-    }
-    const existingProps = JSON.parse(existing.props);
-    const mergedProps = { ...existingProps, ...input.props };
-    const nodeKind = registration.type;
-    const validatedProps = validateNodeProps(nodeKind.schema, mergedProps, {
-      kind,
-      operation: "update",
-      id
-    });
-    const validTo = 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 NodeNotFoundError(kind, id);
-  }
-  const existingProps = JSON.parse(existing.props);
-  const mergedProps = { ...existingProps, ...input.props };
-  const nodeKind = registration.type;
-  const validatedProps = validateNodeProps(nodeKind.schema, mergedProps, {
-    kind,
-    operation: "update",
-    id
-  });
-  const validTo = 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 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) {
@@ -11358,59 +11323,14 @@ 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 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 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);
@@ -11421,8 +11341,11 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
   });
   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(
@@ -11435,23 +11358,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(
@@ -11460,8 +11380,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;
@@ -11500,20 +11423,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,
@@ -11524,11 +11441,7 @@ 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 = validateNodeProps(nodeKind.schema, item.props, {
@@ -11543,49 +11456,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()) {
@@ -11623,73 +11522,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 = 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);
@@ -11700,10 +11554,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,
@@ -11737,8 +11588,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;
     }