@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/chunk-NCX65HBY.cjs

@@ -1,1396 +0,0 @@
-'use strict';
-
-var chunk7V2FGGI2_cjs = require('./chunk-7V2FGGI2.cjs');
-var chunkCPEL3YIR_cjs = require('./chunk-CPEL3YIR.cjs');
-var chunk3PRKZW6D_cjs = require('./chunk-3PRKZW6D.cjs');
-var chunkKKYELPZ2_cjs = require('./chunk-KKYELPZ2.cjs');
-var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
-var chunkZTAJL4DT_cjs = require('./chunk-ZTAJL4DT.cjs');
-var chunkOVUUTCPJ_cjs = require('./chunk-OVUUTCPJ.cjs');
-var chunkU5W4LKZV_cjs = require('./chunk-U5W4LKZV.cjs');
-var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
-var chunkA4PBRX4C_cjs = require('./chunk-A4PBRX4C.cjs');
-var chunkC4F7VJ5D_cjs = require('./chunk-C4F7VJ5D.cjs');
-var chunkTDXIBCGY_cjs = require('./chunk-TDXIBCGY.cjs');
-
-// src/store/row-mappers.ts
-function nullToUndefined(value) {
-  return value === null ? void 0 : value;
-}
-function rowToNode(row) {
-  const rawProps = chunk3PRKZW6D_cjs.rowPropsToObject(row.props);
-  const props = chunkA4PBRX4C_cjs.filterReservedKeys(rawProps, chunkA4PBRX4C_cjs.RESERVED_NODE_KEYS);
-  return {
-    kind: row.kind,
-    id: row.id,
-    meta: rowToNodeMeta(row),
-    ...props
-  };
-}
-function rowToNodeMeta(row) {
-  return {
-    version: row.version,
-    validFrom: nullToUndefined(row.valid_from),
-    validTo: nullToUndefined(row.valid_to),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    deletedAt: nullToUndefined(row.deleted_at)
-  };
-}
-function rowToEdge(row) {
-  const rawProps = chunk3PRKZW6D_cjs.rowPropsToObject(row.props);
-  const props = chunkA4PBRX4C_cjs.filterReservedKeys(rawProps, chunkA4PBRX4C_cjs.RESERVED_EDGE_KEYS);
-  return {
-    id: row.id,
-    kind: row.kind,
-    fromKind: row.from_kind,
-    fromId: row.from_id,
-    toKind: row.to_kind,
-    toId: row.to_id,
-    meta: rowToEdgeMeta(row),
-    ...props
-  };
-}
-function rowToEdgeMeta(row) {
-  return {
-    validFrom: nullToUndefined(row.valid_from),
-    validTo: nullToUndefined(row.valid_to),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    deletedAt: nullToUndefined(row.deleted_at)
-  };
-}
-
-// src/store/operations/write-transaction.ts
-async function lockSchemaVersionForStoreWrite(ctx, backend) {
-  const expectedVersion = ctx.schemaVersion;
-  if (expectedVersion === void 0) return;
-  if ("transaction" in backend && !backend.capabilities.transactions) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      "Schema-managed Store writes require a transactional backend so schema changes and entity writes can share one fence.",
-      {
-        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
-        graphId: ctx.graphId
-      }
-    );
-  }
-  const lockSchemaVersionForWrite = backend.lockSchemaVersionForWrite;
-  if (lockSchemaVersionForWrite === void 0) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      "This backend cannot fence schema-managed Store writes against a concurrent schema change.",
-      {
-        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
-        graphId: ctx.graphId
-      }
-    );
-  }
-  await lockSchemaVersionForWrite({
-    graphId: ctx.graphId,
-    expectedVersion
-  });
-}
-function runInWriteTransaction(ctx, backend, fn) {
-  const ownsWriteLock = "transaction" in backend && backend.capabilities.transactions;
-  return chunk3PRKZW6D_cjs.runOptionallyInTransaction(backend, async (target) => {
-    await lockSchemaVersionForStoreWrite(ctx, target);
-    const lock = ctx.historyEnabled || ctx.revisionTrackingEnabled ? await chunk7V2FGGI2_cjs.lockRecordedGraphWrite(target, ctx.graphId) : chunk7V2FGGI2_cjs.uncapturedGraphWriteLock();
-    const result = await fn(target, lock);
-    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled) {
-      await chunk7V2FGGI2_cjs.advanceRevisionClock(
-        target,
-        ctx.revisionSchema,
-        ctx.graphId,
-        ownsWriteLock
-      );
-    }
-    return result;
-  });
-}
-function runHookedWriteOperation(ctx, opContext, backend, body) {
-  return ctx.withOperationHooks(
-    opContext,
-    () => runInWriteTransaction(ctx, backend, body)
-  );
-}
-
-// src/store/constraints.ts
-async function checkDisjointnessConstraint(ctx, kind, id) {
-  const disjointKinds = ctx.registry.getDisjointKinds(kind);
-  for (const disjointKind of disjointKinds) {
-    const existing = await ctx.backend.getNode(ctx.graphId, disjointKind, id);
-    if (existing && !existing.deleted_at) {
-      const error = chunk7V2FGGI2_cjs.checkDisjointness(id, kind, [disjointKind], ctx.registry);
-      if (error) throw error;
-    }
-  }
-}
-async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind, fromId, toKind, toId, validTo) {
-  switch (cardinality) {
-    case "many": {
-      return;
-    }
-    case "one": {
-      const count = await ctx.backend.countEdgesFrom({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId
-      });
-      const error = chunk7V2FGGI2_cjs.checkCardinality(
-        edgeKind,
-        fromKind,
-        fromId,
-        "one",
-        count,
-        false
-      );
-      if (error) throw error;
-      return;
-    }
-    case "unique": {
-      const exists = await ctx.backend.edgeExistsBetween({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId,
-        toKind,
-        toId
-      });
-      const error = chunk7V2FGGI2_cjs.checkUniqueEdge(
-        edgeKind,
-        fromKind,
-        fromId,
-        toKind,
-        toId,
-        exists ? 1 : 0
-      );
-      if (error) throw error;
-      return;
-    }
-    case "oneActive": {
-      if (validTo !== void 0) {
-        return;
-      }
-      const count = await ctx.backend.countEdgesFrom({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId,
-        activeOnly: true
-      });
-      const error = chunk7V2FGGI2_cjs.checkCardinality(
-        edgeKind,
-        fromKind,
-        fromId,
-        "oneActive",
-        count,
-        count > 0
-      );
-      if (error) throw error;
-      return;
-    }
-  }
-}
-
-// src/store/operations/node-operations.ts
-function getNodeRegistration(graph, kind) {
-  const registration = graph.nodes[kind];
-  if (registration === void 0) throw new chunkC4F7VJ5D_cjs.KindNotFoundError(kind, "node");
-  return registration;
-}
-var CACHE_KEY_SEPARATOR = "\0";
-function buildNodeCacheKey(graphId, kind, id) {
-  return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;
-}
-function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
-  return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;
-}
-function createNodeAlreadyExistsError(kind, id) {
-  return new chunkC4F7VJ5D_cjs.ValidationError(
-    `Node already exists: ${kind}/${id}`,
-    {
-      entityType: "node",
-      kind,
-      operation: "create",
-      id,
-      issues: [{ path: "id", message: "A node with this ID already exists" }]
-    },
-    { suggestion: `Use a different ID or update the existing node.` }
-  );
-}
-function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
-  const insertParams = {
-    graphId,
-    kind,
-    id,
-    props
-  };
-  if (validFrom !== void 0) insertParams.validFrom = validFrom;
-  if (validTo !== void 0) insertParams.validTo = validTo;
-  return insertParams;
-}
-function createPendingUniqueRow(graphId, nodeKind, constraintName, key, nodeId) {
-  return {
-    graph_id: graphId,
-    node_kind: nodeKind,
-    constraint_name: constraintName,
-    key,
-    node_id: nodeId,
-    concrete_kind: nodeKind,
-    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 chunkC4F7VJ5D_cjs.NodeConstraintNotFoundError(constraintName, kind);
-  }
-  return constraint;
-}
-function createNodeBatchValidationBackend(graphId, registry, backend) {
-  const nodeCache = /* @__PURE__ */ new Map();
-  const pendingNodes = /* @__PURE__ */ new Map();
-  const uniqueCache = /* @__PURE__ */ new Map();
-  const pendingUniqueOwners = /* @__PURE__ */ new Map();
-  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);
-    const existing = await backend.getNode(lookupGraphId, kind, id);
-    nodeCache.set(cacheKey, existing);
-    return existing;
-  }
-  async function checkUniqueCached(params) {
-    const cacheKey = buildUniqueCacheKey(
-      params.graphId,
-      params.nodeKind,
-      params.constraintName,
-      params.key
-    );
-    const pendingOwner = pendingUniqueOwners.get(cacheKey);
-    if (pendingOwner !== void 0) {
-      return createPendingUniqueRow(
-        params.graphId,
-        params.nodeKind,
-        params.constraintName,
-        params.key,
-        pendingOwner
-      );
-    }
-    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);
-    pendingNodes.set(cacheKey, {
-      graph_id: params.graphId,
-      kind: params.kind,
-      id: params.id,
-      props: JSON.stringify(params.props),
-      version: 1,
-      // The simulated cached row only needs a NodeRow-shaped valid_from
-      // (string | undefined, never null) for existence/uniqueness checks,
-      // which don't inspect its value — normalize import's explicit-NULL
-      // sentinel away rather than widen this cache's row shape.
-      valid_from: params.validFrom ?? void 0,
-      valid_to: params.validTo,
-      created_at: "",
-      updated_at: "",
-      deleted_at: void 0
-    });
-  }
-  function registerPendingUniqueEntries(kind, id, props, constraints) {
-    for (const constraint of constraints) {
-      if (!chunk7V2FGGI2_cjs.checkWherePredicate(constraint, props)) continue;
-      const key = chunk7V2FGGI2_cjs.computeUniqueKey(
-        props,
-        constraint.fields,
-        constraint.collation
-      );
-      const concreteEntryKey = buildUniqueCacheKey(
-        graphId,
-        kind,
-        constraint.name,
-        key
-      );
-      pendingUniqueOwners.set(concreteEntryKey, id);
-      if (constraint.scope !== "kind") {
-        const kindsToCheck = chunk7V2FGGI2_cjs.getKindsForUniquenessCheck(
-          kind,
-          constraint.scope,
-          registry
-        );
-        for (const kindToCheck of kindsToCheck) {
-          const inheritedEntryKey = buildUniqueCacheKey(
-            graphId,
-            kindToCheck,
-            constraint.name,
-            key
-          );
-          pendingUniqueOwners.set(inheritedEntryKey, id);
-        }
-      }
-    }
-  }
-  function registerAppliedNodeUpdate(kind, id, oldProps, newProps, constraints) {
-    for (const constraint of constraints) {
-      const oldApplies = chunk7V2FGGI2_cjs.checkWherePredicate(constraint, oldProps);
-      const newApplies = chunk7V2FGGI2_cjs.checkWherePredicate(constraint, newProps);
-      const oldKey = oldApplies ? chunk7V2FGGI2_cjs.computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
-      const newKey = newApplies ? chunk7V2FGGI2_cjs.computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
-      if (oldKey === newKey) continue;
-      const kindsToCheck = chunk7V2FGGI2_cjs.getKindsForUniquenessCheck(
-        kind,
-        constraint.scope,
-        registry
-      );
-      if (oldKey !== void 0) {
-        for (const kindToCheck of kindsToCheck) {
-          const cacheKey = buildUniqueCacheKey(
-            graphId,
-            kindToCheck,
-            constraint.name,
-            oldKey
-          );
-          pendingUniqueOwners.delete(cacheKey);
-          uniqueCache.set(cacheKey, void 0);
-        }
-      }
-      if (newKey !== void 0) {
-        for (const kindToCheck of kindsToCheck) {
-          const cacheKey = buildUniqueCacheKey(
-            graphId,
-            kindToCheck,
-            constraint.name,
-            newKey
-          );
-          pendingUniqueOwners.set(cacheKey, id);
-        }
-      }
-    }
-  }
-  function seedNodeRow(kind, id, row) {
-    const cacheKey = buildNodeCacheKey(graphId, kind, id);
-    if (nodeCache.has(cacheKey)) return;
-    nodeCache.set(cacheKey, row);
-  }
-  function seedUniqueRow(kind, constraintName, key, row) {
-    const cacheKey = buildUniqueCacheKey(graphId, kind, constraintName, key);
-    if (uniqueCache.has(cacheKey)) return;
-    uniqueCache.set(cacheKey, row);
-  }
-  const validationBackend = chunk3PRKZW6D_cjs.createBackendOverlay(backend, {
-    getNode: getNodeCached,
-    checkUnique: checkUniqueCached
-  });
-  return {
-    backend: validationBackend,
-    registerPendingNode,
-    registerPendingUniqueEntries,
-    registerAppliedNodeUpdate,
-    seedNodeRow,
-    seedUniqueRow
-  };
-}
-function draftNodeCreate(ctx, input, id, options) {
-  const kind = input.kind;
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const validatedProps = options?.propsPreValidated === true ? input.props : chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, input.props, {
-    kind,
-    operation: "create"
-  });
-  return {
-    kind,
-    id,
-    nodeKind,
-    uniqueConstraints: registration.unique ?? [],
-    validatedProps,
-    validFrom: chunkZTAJL4DT_cjs.validateOptionalCanonicalIsoDate(input.validFrom, "validFrom"),
-    validTo: chunkZTAJL4DT_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo")
-  };
-}
-async function finishNodeCreatePreparation(ctx, draft, backend) {
-  const { kind, id, validatedProps, uniqueConstraints } = draft;
-  const existingNode = await backend.getNode(ctx.graphId, kind, id);
-  if (existingNode && !existingNode.deleted_at) {
-    throw createNodeAlreadyExistsError(kind, id);
-  }
-  const constraintContext = {
-    graphId: ctx.graphId,
-    registry: ctx.registry,
-    backend
-  };
-  await checkDisjointnessConstraint(constraintContext, kind, id);
-  await chunk7V2FGGI2_cjs.checkUniquenessConstraints(
-    chunk7V2FGGI2_cjs.createUniquenessContext(ctx.graphId, ctx.registry, backend),
-    kind,
-    id,
-    validatedProps,
-    uniqueConstraints
-  );
-  return {
-    kind,
-    id,
-    nodeKind: draft.nodeKind,
-    validatedProps,
-    uniqueConstraints,
-    insertParams: buildInsertNodeParams(
-      ctx.graphId,
-      kind,
-      id,
-      validatedProps,
-      draft.validFrom,
-      draft.validTo
-    )
-  };
-}
-async function validateAndPrepareNodeCreate(ctx, input, id, backend, options) {
-  return finishNodeCreatePreparation(
-    ctx,
-    draftNodeCreate(ctx, input, id, options),
-    backend
-  );
-}
-async function finalizeNodeCreateBatch(ctx, preparedCreates, backend, lock) {
-  await chunk7V2FGGI2_cjs.applyNodeInsertSideEffectsBatch(
-    chunk7V2FGGI2_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-    preparedCreates.map((prepared) => ({
-      kind: prepared.kind,
-      id: prepared.id,
-      schema: prepared.nodeKind.schema,
-      props: prepared.validatedProps,
-      uniqueConstraints: prepared.uniqueConstraints
-    })),
-    backend
-  );
-}
-async function finalizeNodeCreate(ctx, prepared, backend, lock) {
-  await chunk7V2FGGI2_cjs.applyNodeInsertSideEffects(
-    chunk7V2FGGI2_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-    {
-      kind: prepared.kind,
-      id: prepared.id,
-      schema: prepared.nodeKind.schema,
-      props: prepared.validatedProps,
-      uniqueConstraints: prepared.uniqueConstraints
-    },
-    backend
-  );
-}
-function computeNodeUpdate(ctx, kind, id, existingProps, inputProps) {
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const validatedProps = chunkKKYELPZ2_cjs.validateNodeProps(
-    registration.type.schema,
-    { ...existingProps, ...inputProps },
-    { kind, operation: "update", id }
-  );
-  return { registration, validatedProps };
-}
-function resolveNodeUpdateProps(ctx, existing, inputProps) {
-  const existingProps = chunk3PRKZW6D_cjs.rowPropsToObject(existing.props);
-  const { registration, validatedProps } = computeNodeUpdate(
-    ctx,
-    existing.kind,
-    existing.id,
-    existingProps,
-    inputProps
-  );
-  return { registration, existingProps, validatedProps };
-}
-function nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
-  const { validatedProps } = computeNodeUpdate(
-    ctx,
-    kind,
-    id,
-    existingProps,
-    inputProps
-  );
-  return {
-    validatedProps,
-    unchanged: chunkACSVZPK7_cjs.canonicalEqual(validatedProps, existingProps)
-  };
-}
-async function performNodeUpdate(ctx, input, backend, lock, options) {
-  const { kind, id } = input;
-  const existing = await backend.getNode(ctx.graphId, kind, id);
-  if (!existing) throw new chunkC4F7VJ5D_cjs.NodeNotFoundError(kind, id);
-  const { registration, validatedProps } = resolveNodeUpdateProps(
-    ctx,
-    existing,
-    input.props
-  );
-  const nodeKind = registration.type;
-  const validTo = chunkZTAJL4DT_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  const writeContext = chunk7V2FGGI2_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock);
-  const shared = {
-    schema: nodeKind.schema,
-    validatedProps,
-    uniqueConstraints: registration.unique ?? [],
-    ...validTo !== void 0 && { validTo }
-  };
-  if (options?.clearDeleted) {
-    const row2 = await chunk7V2FGGI2_cjs.applyNodeUpdate(
-      writeContext,
-      { ...shared, existing, clearDeleted: true },
-      backend
-    );
-    return rowToNode(row2);
-  }
-  if (!chunk3PRKZW6D_cjs.isLiveNodeRow(existing)) throw new chunkC4F7VJ5D_cjs.NodeNotFoundError(kind, id);
-  const row = await chunk7V2FGGI2_cjs.applyNodeUpdate(
-    writeContext,
-    { ...shared, existing },
-    backend
-  );
-  return rowToNode(row);
-}
-async function primeBatchValidationCaches(ctx, drafts, backend, seams) {
-  if (backend.getNodes !== void 0) {
-    const idsByKind = /* @__PURE__ */ new Map();
-    for (const draft of drafts) {
-      const ids = idsByKind.get(draft.kind) ?? /* @__PURE__ */ new Set();
-      ids.add(draft.id);
-      idsByKind.set(draft.kind, ids);
-    }
-    for (const [kind, ids] of idsByKind) {
-      const orderedIds = [...ids];
-      const rows = await backend.getNodes(ctx.graphId, kind, orderedIds);
-      const rowsById = new Map(rows.map((row) => [row.id, row]));
-      for (const id of orderedIds) {
-        seams.seedNodeRow(kind, id, rowsById.get(id));
-      }
-    }
-  }
-  if (backend.checkUniqueBatch !== void 0) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const draft of drafts) {
-      for (const constraint of draft.uniqueConstraints) {
-        if (!chunk7V2FGGI2_cjs.checkWherePredicate(constraint, draft.validatedProps)) continue;
-        const key = chunk7V2FGGI2_cjs.computeUniqueKey(
-          draft.validatedProps,
-          constraint.fields,
-          constraint.collation
-        );
-        const kindsToCheck = chunk7V2FGGI2_cjs.getKindsForUniquenessCheck(
-          draft.kind,
-          constraint.scope,
-          ctx.registry
-        );
-        for (const kindToCheck of kindsToCheck) {
-          const groupKey = kindToCheck + CACHE_KEY_SEPARATOR + constraint.name;
-          const group = groups.get(groupKey) ?? {
-            nodeKind: kindToCheck,
-            constraintName: constraint.name,
-            keys: /* @__PURE__ */ new Set()
-          };
-          group.keys.add(key);
-          groups.set(groupKey, group);
-        }
-      }
-    }
-    for (const group of groups.values()) {
-      const orderedKeys = [...group.keys];
-      const rows = await backend.checkUniqueBatch({
-        graphId: ctx.graphId,
-        nodeKind: group.nodeKind,
-        constraintName: group.constraintName,
-        keys: orderedKeys
-      });
-      const rowsByKey = new Map(rows.map((row) => [row.key, row]));
-      for (const key of orderedKeys) {
-        seams.seedUniqueRow(
-          group.nodeKind,
-          group.constraintName,
-          key,
-          rowsByKey.get(key)
-        );
-      }
-    }
-  }
-}
-async function prepareBatchCreates(ctx, inputs, backend, options) {
-  const {
-    backend: validationBackend,
-    registerPendingNode,
-    registerPendingUniqueEntries,
-    seedNodeRow,
-    seedUniqueRow
-  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
-  const drafts = inputs.map(
-    (input) => draftNodeCreate(ctx, input, input.id ?? chunk7V2FGGI2_cjs.generateId(), options)
-  );
-  await primeBatchValidationCaches(ctx, drafts, backend, {
-    seedNodeRow,
-    seedUniqueRow
-  });
-  const preparedCreates = [];
-  for (const draft of drafts) {
-    const prepared = await finishNodeCreatePreparation(
-      ctx,
-      draft,
-      validationBackend
-    );
-    preparedCreates.push(prepared);
-    registerPendingNode(prepared.insertParams);
-    registerPendingUniqueEntries(
-      prepared.kind,
-      prepared.id,
-      prepared.validatedProps,
-      prepared.uniqueConstraints
-    );
-  }
-  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 ?? chunk7V2FGGI2_cjs.generateId();
-  const opContext = ctx.createOperationContext("create", "node", kind, id);
-  const shouldReturnRow = options?.returnRow ?? true;
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    async (target, lock) => {
-      const prepared = await validateAndPrepareNodeCreate(
-        ctx,
-        input,
-        id,
-        target,
-        options
-      );
-      let row;
-      if (shouldReturnRow) {
-        row = await target.insertNode(prepared.insertParams);
-      } else {
-        await chunk7V2FGGI2_cjs.runInsertNoReturn(
-          chunk7V2FGGI2_cjs.nodeInsertDispatch(target),
-          prepared.insertParams
-        );
-      }
-      await finalizeNodeCreate(ctx, prepared, target, lock);
-      if (row === void 0) return;
-      return rowToNode(row);
-    }
-  );
-}
-async function executeNodeCreate(ctx, input, backend, options) {
-  const result = await executeNodeCreateInternal(ctx, input, backend, {
-    returnRow: true,
-    ...options
-  });
-  if (!result) {
-    throw new chunkC4F7VJ5D_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;
-  await runInWriteTransaction(ctx, backend, async (target, lock) => {
-    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
-      ctx,
-      inputs,
-      target
-    );
-    await chunk7V2FGGI2_cjs.runInsertBatch(chunk7V2FGGI2_cjs.nodeInsertDispatch(target), batchInsertParams);
-    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
-  });
-}
-async function executeNodeCreateBatch(ctx, inputs, backend, options) {
-  if (inputs.length === 0) return [];
-  return runInWriteTransaction(ctx, backend, async (target, lock) => {
-    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
-      ctx,
-      inputs,
-      target,
-      options
-    );
-    const rows = await chunk7V2FGGI2_cjs.runInsertBatchReturning(
-      chunk7V2FGGI2_cjs.nodeInsertDispatch(target),
-      batchInsertParams
-    );
-    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
-    return rows.map((row) => rowToNode(row));
-  });
-}
-async function executeNodeUpdate(ctx, input, backend, options) {
-  const opContext = ctx.createOperationContext(
-    "update",
-    "node",
-    input.kind,
-    input.id
-  );
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
-  );
-}
-async function executeNodeUpsertUpdate(ctx, input, backend, options) {
-  return runInWriteTransaction(
-    ctx,
-    backend,
-    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
-  );
-}
-async function executeNodeDelete(ctx, kind, id, backend) {
-  const gate = await backend.getNode(ctx.graphId, kind, id);
-  if (!gate || gate.deleted_at) return;
-  const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    async (target, lock) => {
-      const registration = getNodeRegistration(ctx.graph, kind);
-      const preflight = await target.getNode(ctx.graphId, kind, id);
-      if (!preflight || !chunk3PRKZW6D_cjs.isLiveNodeRow(preflight)) return;
-      await chunk7V2FGGI2_cjs.applyNodeSoftDelete(
-        chunk7V2FGGI2_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-        {
-          existing: preflight,
-          schema: registration.type.schema,
-          uniqueConstraints: registration.unique ?? [],
-          onDelete: registration.onDelete
-        },
-        target
-      );
-    }
-  );
-}
-async function executeNodeHardDelete(ctx, kind, id, backend) {
-  const gate = await backend.getNode(ctx.graphId, kind, id);
-  if (!gate) return;
-  const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return runHookedWriteOperation(
-    ctx,
-    opContext,
-    backend,
-    async (target, lock) => {
-      const registration = getNodeRegistration(ctx.graph, kind);
-      await chunk7V2FGGI2_cjs.applyNodeHardDelete(
-        chunk7V2FGGI2_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-        {
-          kind,
-          id,
-          schema: registration.type.schema,
-          onDelete: registration.onDelete
-        },
-        target
-      );
-    }
-  );
-}
-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 = chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, props, {
-    kind,
-    operation: "create"
-  });
-  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!chunk7V2FGGI2_cjs.checkWherePredicate(constraint, validatedProps)) {
-    const node = await executeNodeCreate(
-      ctx,
-      { kind, props: validatedProps },
-      backend,
-      { propsPreValidated: true }
-    );
-    return { node, action: "created" };
-  }
-  const key = chunk7V2FGGI2_cjs.computeUniqueKey(
-    validatedProps,
-    constraint.fields,
-    constraint.collation
-  );
-  const kindsToCheck = chunk7V2FGGI2_cjs.getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  async function attempt() {
-    const existingUniqueRow = await findUniqueRowAcrossKinds(
-      backend,
-      ctx.graphId,
-      constraint.name,
-      key,
-      kindsToCheck,
-      true
-    );
-    if (existingUniqueRow === void 0) {
-      const node = await executeNodeCreate(
-        ctx,
-        { kind, props: validatedProps },
-        backend,
-        { propsPreValidated: true }
-      );
-      return { node, action: "created" };
-    }
-    const existingRow = await backend.getNode(
-      ctx.graphId,
-      existingUniqueRow.concrete_kind,
-      existingUniqueRow.node_id
-    );
-    if (existingRow === void 0) {
-      const node = await executeNodeCreate(
-        ctx,
-        { kind, props: validatedProps },
-        backend,
-        { propsPreValidated: true }
-      );
-      return { node, action: "created" };
-    }
-    const isSoftDeleted = existingRow.deleted_at !== void 0;
-    if (isSoftDeleted || ifExists === "update") {
-      const concreteKind = existingUniqueRow.concrete_kind;
-      const node = await executeNodeUpsertUpdate(
-        ctx,
-        {
-          kind: concreteKind,
-          id: existingRow.id,
-          props: validatedProps
-        },
-        backend,
-        { clearDeleted: isSoftDeleted }
-      );
-      return { node, action: isSoftDeleted ? "resurrected" : "updated" };
-    }
-    return { node: rowToNode(existingRow), action: "found" };
-  }
-  try {
-    return await attempt();
-  } catch (error) {
-    if (!(error instanceof chunkC4F7VJ5D_cjs.UniquenessError)) throw error;
-    return attempt();
-  }
-}
-async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
-  const registration = getNodeRegistration(ctx.graph, kind);
-  const nodeKind = registration.type;
-  const validatedProps = chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, props, {
-    kind,
-    operation: "create"
-  });
-  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!chunk7V2FGGI2_cjs.checkWherePredicate(constraint, validatedProps)) return void 0;
-  const key = chunk7V2FGGI2_cjs.computeUniqueKey(
-    validatedProps,
-    constraint.fields,
-    constraint.collation
-  );
-  const kindsToCheck = chunk7V2FGGI2_cjs.getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  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,
-    existingUniqueRow.concrete_kind,
-    existingUniqueRow.node_id
-  );
-  if (existingRow === void 0 || existingRow.deleted_at !== void 0)
-    return void 0;
-  return rowToNode(existingRow);
-}
-function validateAndComputeKeys(nodeKind, kind, constraint, items) {
-  const validated = [];
-  for (const item of items) {
-    const validatedProps = chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, item.props, {
-      kind,
-      operation: "create"
-    });
-    const applies = chunk7V2FGGI2_cjs.checkWherePredicate(constraint, validatedProps);
-    const key = applies ? chunk7V2FGGI2_cjs.computeUniqueKey(
-      validatedProps,
-      constraint.fields,
-      constraint.collation
-    ) : void 0;
-    validated.push({ validatedProps, key });
-  }
-  return validated;
-}
-function collectUniqueKeys(validated) {
-  return [
-    ...new Set(
-      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 = chunk7V2FGGI2_cjs.getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  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()) {
-    if (key === void 0) {
-      results[index] = void 0;
-      continue;
-    }
-    const previousIndex = seenKeys.get(key);
-    if (previousIndex !== void 0) {
-      results[index] = results[previousIndex];
-      continue;
-    }
-    seenKeys.set(key, index);
-    const existing = existingByKey.get(key);
-    if (existing === void 0) {
-      results[index] = void 0;
-      continue;
-    }
-    const existingRow = await backend.getNode(
-      ctx.graphId,
-      existing.concrete_kind,
-      existing.node_id
-    );
-    if (existingRow === void 0 || existingRow.deleted_at !== void 0) {
-      results[index] = void 0;
-      continue;
-    }
-    results[index] = rowToNode(existingRow);
-  }
-  return results;
-}
-function resolveNodeIndex(graph, kind, indexName) {
-  getNodeRegistration(graph, kind);
-  const declaration = graph.indexes?.find(
-    (candidate) => candidate.entity === "node" && candidate.kind === kind && candidate.name === indexName
-  );
-  if (declaration?.entity !== "node") {
-    throw new chunkC4F7VJ5D_cjs.NodeIndexNotFoundError(indexName, kind);
-  }
-  if (declaration.method !== void 0) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      `bulkFindByIndex cannot probe index "${indexName}" (method "${declaration.method}"): only btree indexes serve equality probes.`,
-      { indexName, kind, method: declaration.method }
-    );
-  }
-  return declaration;
-}
-var INDEX_PROBE_EXPECTED_TYPEOF = {
-  string: "string",
-  number: "number",
-  boolean: "boolean"
-};
-function validateIndexProbeValue(value, valueType, pointer, kind) {
-  if (value === void 0 || value === null) return;
-  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && !(value instanceof Date)) {
-    throw indexProbeTypeError(
-      pointer,
-      kind,
-      "a scalar (string, number, boolean, or Date)",
-      value
-    );
-  }
-  if (valueType === "date") {
-    if (value instanceof Date || typeof value === "string") return;
-    throw indexProbeTypeError(
-      pointer,
-      kind,
-      "date (Date or ISO string)",
-      value
-    );
-  }
-  const expected = INDEX_PROBE_EXPECTED_TYPEOF[valueType ?? "unknown"];
-  if (expected === void 0) return;
-  if (typeof value !== expected) {
-    throw indexProbeTypeError(pointer, kind, expected, value);
-  }
-}
-function indexProbeTypeError(pointer, kind, expected, value) {
-  return new chunkC4F7VJ5D_cjs.ValidationError(
-    `Index probe value for "${pointer}" on node kind "${kind}" has an incompatible type`,
-    {
-      entityType: "node",
-      kind,
-      issues: [
-        {
-          path: pointer,
-          message: `Expected ${expected}, received ${typeof value}`,
-          code: "invalid_type"
-        }
-      ]
-    }
-  );
-}
-function coerceIndexProbeBind(value, adapter) {
-  return adapter.bindValue(normalizeProbeScalar(value));
-}
-function normalizeProbeScalar(value) {
-  return value instanceof Date ? value.toISOString() : value;
-}
-var PROBE_NULL_TAG = 0;
-var PROBE_VALUE_TAG = 1;
-function canonicalIndexProbeKey(probe) {
-  return JSON.stringify(
-    probe.map(
-      (value) => value === void 0 || value === null ? [PROBE_NULL_TAG] : [PROBE_VALUE_TAG, normalizeProbeScalar(value)]
-    )
-  );
-}
-async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend, options) {
-  if (items.length === 0) return [];
-  const index = resolveNodeIndex(ctx.graph, kind, indexName);
-  if (index.fields.length === 0) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      `bulkFindByIndex requires an index with at least one prop-based field on index "${indexName}" (node kind "${kind}")`,
-      { indexName, kind },
-      {
-        suggestion: "bulkFindByIndex probes by prop values from each item; an index declared with only keySystemColumns/coveringFields (no fields) has nothing to probe by."
-      }
-    );
-  }
-  if (index.fieldValueTypes.includes("date")) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      `bulkFindByIndex does not support date-typed key fields on index "${indexName}" (node kind "${kind}")`,
-      { indexName, kind },
-      {
-        suggestion: "Date index keys compare differently across SQLite and PostgreSQL. Use a string-encoded key field, or query date predicates via store.query(...).where(...)."
-      }
-    );
-  }
-  const limitPerInput = options?.limitPerInput;
-  if (limitPerInput !== void 0 && (!Number.isInteger(limitPerInput) || limitPerInput <= 0)) {
-    throw new chunkC4F7VJ5D_cjs.ValidationError(
-      "bulkFindByIndex limitPerInput must be a positive integer",
-      {
-        entityType: "node",
-        kind,
-        issues: [
-          {
-            path: "limitPerInput",
-            message: `Expected a positive integer, received ${String(limitPerInput)}`,
-            code: "invalid_value"
-          }
-        ]
-      }
-    );
-  }
-  const adapter = chunkOVUUTCPJ_cjs.getDialect(backend.dialect);
-  const probes = items.map(
-    (item) => index.fields.map((pointer, position) => {
-      const value = chunkTDXIBCGY_cjs.resolveJsonPointer(item.props, pointer);
-      validateIndexProbeValue(
-        value,
-        index.fieldValueTypes[position],
-        pointer,
-        kind
-      );
-      return value;
-    })
-  );
-  const groupByKey = /* @__PURE__ */ new Map();
-  const groupProbes = [];
-  const groupToInputs = [];
-  for (const [inputIndex, probe] of probes.entries()) {
-    const key = canonicalIndexProbeKey(probe);
-    const existing = groupByKey.get(key);
-    if (existing === void 0) {
-      groupByKey.set(key, groupProbes.length);
-      groupProbes.push(probe);
-      groupToInputs.push([inputIndex]);
-      continue;
-    }
-    groupToInputs[existing]?.push(inputIndex);
-  }
-  const schema = backend.tableNames ? chunkCPEL3YIR_cjs.createSqlSchema(backend.tableNames) : chunkCPEL3YIR_cjs.DEFAULT_SQL_SCHEMA;
-  const compileContext = {
-    dialect: backend.dialect,
-    propsColumn: chunkU5W4LKZV_cjs.sql.raw(`"props"`),
-    systemColumn: (column) => chunkU5W4LKZV_cjs.sql.raw(`"${column}"`)
-  };
-  const fieldKeys = chunkOVUUTCPJ_cjs.compileNodeIndexFieldKeys(index, compileContext);
-  const groupPredicates = groupProbes.map(
-    (probe) => chunkU5W4LKZV_cjs.sql`(${chunkU5W4LKZV_cjs.sql.join(
-      fieldKeys.map((fieldKey, position) => {
-        const value = probe[position];
-        if (value === void 0 || value === null) {
-          return chunkU5W4LKZV_cjs.sql`${fieldKey} IS NULL`;
-        }
-        return adapter.nullSafeEquals(
-          fieldKey,
-          chunkU5W4LKZV_cjs.sql`${coerceIndexProbeBind(value, adapter)}`
-        );
-      }),
-      chunkU5W4LKZV_cjs.sql` AND `
-    )})`
-  );
-  const caseBranches = groupPredicates.map(
-    (predicate, group) => chunkU5W4LKZV_cjs.sql`WHEN ${predicate} THEN ${chunkU5W4LKZV_cjs.sql.raw(String(group))}`
-  );
-  const probeIndexExpr = chunkU5W4LKZV_cjs.sql`CASE ${chunkU5W4LKZV_cjs.sql.join(caseBranches, chunkU5W4LKZV_cjs.sql` `)} ELSE NULL END`;
-  const conditions = [
-    chunkU5W4LKZV_cjs.sql`"graph_id" = ${ctx.graphId}`,
-    chunkU5W4LKZV_cjs.sql`"kind" = ${kind}`,
-    chunkU5W4LKZV_cjs.sql`"deleted_at" IS NULL`
-  ];
-  if (index.where !== void 0) {
-    conditions.push(chunkOVUUTCPJ_cjs.compileIndexWhere(compileContext, index.where));
-  }
-  conditions.push(chunkU5W4LKZV_cjs.sql`(${chunkU5W4LKZV_cjs.sql.join(groupPredicates, chunkU5W4LKZV_cjs.sql` OR `)})`);
-  const whereClause = chunkU5W4LKZV_cjs.sql.join(conditions, chunkU5W4LKZV_cjs.sql` AND `);
-  const probedSelect = chunkU5W4LKZV_cjs.sql`SELECT "id", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;
-  const capInSql = limitPerInput !== void 0 && backend.capabilities.windowFunctions;
-  const query = capInSql ? chunkU5W4LKZV_cjs.sql`SELECT "id", probe_idx FROM (SELECT "id", probe_idx, ROW_NUMBER() OVER (PARTITION BY probe_idx ORDER BY "id") AS probe_rank FROM (${probedSelect}) AS probed) AS ranked WHERE probe_rank <= ${limitPerInput} ORDER BY probe_idx, "id"` : chunkU5W4LKZV_cjs.sql`${probedSelect} ORDER BY probe_idx, "id"`;
-  const rawMatches = await backend.execute(
-    chunkU5W4LKZV_cjs.asCompiledRowsSql(query)
-  );
-  const matches = limitPerInput !== void 0 && !capInSql ? capMatchesPerGroup(rawMatches, limitPerInput) : rawMatches;
-  const nodesById = await hydrateNodesById(
-    backend,
-    ctx.graphId,
-    kind,
-    matches.map((match) => match.id)
-  );
-  const results = Array.from({ length: items.length }, () => []);
-  for (const match of matches) {
-    const node = nodesById.get(match.id);
-    if (node === void 0) continue;
-    const inputs = groupToInputs[match.probe_idx];
-    if (inputs === void 0) continue;
-    for (const inputIndex of inputs) {
-      results[inputIndex]?.push(node);
-    }
-  }
-  return results;
-}
-function capMatchesPerGroup(matches, limitPerInput) {
-  const perGroupCount = /* @__PURE__ */ new Map();
-  const capped = [];
-  for (const match of matches) {
-    const count = perGroupCount.get(match.probe_idx) ?? 0;
-    if (count >= limitPerInput) continue;
-    perGroupCount.set(match.probe_idx, count + 1);
-    capped.push(match);
-  }
-  return capped;
-}
-async function hydrateNodesById(backend, graphId, kind, ids) {
-  const rowsById = await chunk7V2FGGI2_cjs.getNodeRowsByIds(backend, graphId, kind, ids);
-  const nodesById = /* @__PURE__ */ new Map();
-  for (const [id, row] of rowsById) {
-    if (row.deleted_at !== void 0) continue;
-    nodesById.set(id, rowToNode(row));
-  }
-  return nodesById;
-}
-async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName, items, backend, options) {
-  if (items.length === 0) return [];
-  const ifExists = options?.ifExists ?? "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 = chunk7V2FGGI2_cjs.getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  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 } });
-      continue;
-    }
-    const previousIndex = seenKeys.get(key);
-    if (previousIndex !== void 0) {
-      duplicateOf.push({ index, sourceIndex: previousIndex });
-      continue;
-    }
-    seenKeys.set(key, index);
-    const existing = existingByKey.get(key);
-    if (existing === void 0) {
-      toCreate.push({ index, input: { kind, props: validatedProps } });
-    } else {
-      toFetch.push({
-        index,
-        nodeId: existing.node_id,
-        concreteKind: existing.concrete_kind,
-        validatedProps,
-        isSoftDeleted: existing.deleted_at !== void 0
-      });
-    }
-  }
-  const results = Array.from({ length: items.length });
-  if (toCreate.length > 0) {
-    const createInputs = toCreate.map((entry) => entry.input);
-    const createdNodes = await executeNodeCreateBatch(
-      ctx,
-      createInputs,
-      backend,
-      { propsPreValidated: true }
-    );
-    for (const [batchIndex, entry] of toCreate.entries()) {
-      results[entry.index] = {
-        node: chunk764JHTLT_cjs.requireDefined(createdNodes[batchIndex]),
-        action: "created"
-      };
-    }
-  }
-  for (const entry of toFetch) {
-    const { index, concreteKind, validatedProps, isSoftDeleted, nodeId } = entry;
-    const existingRow = await backend.getNode(
-      ctx.graphId,
-      concreteKind,
-      nodeId
-    );
-    if (existingRow === void 0) {
-      const node = await executeNodeCreate(
-        ctx,
-        { kind, props: validatedProps },
-        backend,
-        { propsPreValidated: true }
-      );
-      results[index] = { node, action: "created" };
-      continue;
-    }
-    if (isSoftDeleted || ifExists === "update") {
-      const node = await executeNodeUpsertUpdate(
-        ctx,
-        {
-          kind: concreteKind,
-          id: existingRow.id,
-          props: validatedProps
-        },
-        backend,
-        { clearDeleted: isSoftDeleted }
-      );
-      results[index] = {
-        node,
-        action: isSoftDeleted ? "resurrected" : "updated"
-      };
-    } else {
-      results[index] = { node: rowToNode(existingRow), action: "found" };
-    }
-  }
-  for (const { index, sourceIndex } of duplicateOf) {
-    const sourceResult = chunk764JHTLT_cjs.requireDefined(results[sourceIndex]);
-    results[index] = { node: sourceResult.node, action: "found" };
-  }
-  return results;
-}
-
-exports.checkCardinalityConstraint = checkCardinalityConstraint;
-exports.createNodeBatchValidationBackend = createNodeBatchValidationBackend;
-exports.executeNodeBulkFindByConstraint = executeNodeBulkFindByConstraint;
-exports.executeNodeBulkFindByIndex = executeNodeBulkFindByIndex;
-exports.executeNodeBulkGetOrCreateByConstraint = executeNodeBulkGetOrCreateByConstraint;
-exports.executeNodeCreate = executeNodeCreate;
-exports.executeNodeCreateBatch = executeNodeCreateBatch;
-exports.executeNodeCreateNoReturnBatch = executeNodeCreateNoReturnBatch;
-exports.executeNodeDelete = executeNodeDelete;
-exports.executeNodeFindByConstraint = executeNodeFindByConstraint;
-exports.executeNodeGetOrCreateByConstraint = executeNodeGetOrCreateByConstraint;
-exports.executeNodeHardDelete = executeNodeHardDelete;
-exports.executeNodeUpdate = executeNodeUpdate;
-exports.executeNodeUpsertUpdate = executeNodeUpsertUpdate;
-exports.lockSchemaVersionForStoreWrite = lockSchemaVersionForStoreWrite;
-exports.nodeUpsertDirtyCheck = nodeUpsertDirtyCheck;
-exports.primeBatchValidationCaches = primeBatchValidationCaches;
-exports.rowToEdge = rowToEdge;
-exports.rowToEdgeMeta = rowToEdgeMeta;
-exports.rowToNode = rowToNode;
-exports.rowToNodeMeta = rowToNodeMeta;
-exports.runHookedWriteOperation = runHookedWriteOperation;
-exports.runInWriteTransaction = runInWriteTransaction;
-//# sourceMappingURL=chunk-NCX65HBY.cjs.map
-//# sourceMappingURL=chunk-NCX65HBY.cjs.map