@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/chunk-I4GAZH5Z.js

@@ -1,913 +0,0 @@
-import { encodeTupleKey } from './chunk-S5TERQVW.js';
-import { rowPropsToObject } from './chunk-6LN7FIVU.js';
-import { checkWherePredicate, computeUniqueKey, getKindsForUniquenessCheck } from './chunk-GLHXM7C4.js';
-import { typeGraphGlobalSymbol } from './chunk-3DMMGT6S.js';
-import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-PC2UBAUB.js';
-import { ConfigurationError, UniquenessError, RestrictedDeleteError } from './chunk-ZLONH2UD.js';
-import { readOwnProperty } from './chunk-DYATYRY4.js';
-
-// src/store/types.ts
-var AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1e3;
-var TRANSACTION_RUNTIME = typeGraphGlobalSymbol(
-  "transaction-runtime-v1"
-);
-
-// src/store/runtime-port.ts
-var STORE_RUNTIME = typeGraphGlobalSymbol("store-runtime-v1");
-function storeRuntime(store) {
-  const runtime = store[STORE_RUNTIME];
-  if (runtime === void 0) {
-    throw new TypeError(
-      "Cannot access this Store's runtime port. The Store may come from an incompatible TypeGraph version."
-    );
-  }
-  return runtime;
-}
-function storeBackend(store) {
-  return storeRuntime(store).backend;
-}
-function transactionBackend(transaction) {
-  const runtime = transaction[TRANSACTION_RUNTIME];
-  if (runtime === void 0) {
-    throw new TypeError(
-      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
-    );
-  }
-  return runtime.backend;
-}
-function transactionNodeOperationHookRunner(transaction) {
-  const runtime = transaction[TRANSACTION_RUNTIME];
-  if (runtime === void 0) {
-    throw new TypeError(
-      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
-    );
-  }
-  return runtime.runNodeOperationHooks;
-}
-
-// src/store/embedding-sync.ts
-var embeddingFieldsCache = /* @__PURE__ */ new WeakMap();
-function getEmbeddingFields(schema) {
-  const cached = embeddingFieldsCache.get(schema);
-  if (cached) return cached;
-  const fields = resolveEmbeddingFields(schema);
-  embeddingFieldsCache.set(schema, fields);
-  return fields;
-}
-async function syncEmbeddings(ctx, schema, props) {
-  const { backend } = ctx;
-  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
-    return;
-  }
-  const embeddingFields = getEmbeddingFields(schema);
-  if (embeddingFields.length === 0) {
-    return;
-  }
-  for (const field of embeddingFields) {
-    const value = readOwnProperty(props, field.fieldPath);
-    if (isValidEmbeddingValue(value)) {
-      await backend.upsertEmbedding({
-        graphId: ctx.graphId,
-        nodeKind: ctx.nodeKind,
-        nodeId: ctx.nodeId,
-        fieldPath: field.fieldPath,
-        embedding: value,
-        dimensions: field.dimensions,
-        metric: field.metric,
-        indexType: field.indexType
-      });
-    } else if (value === void 0) {
-      await backend.deleteEmbedding({
-        graphId: ctx.graphId,
-        nodeKind: ctx.nodeKind,
-        nodeId: ctx.nodeId,
-        fieldPath: field.fieldPath,
-        dimensions: field.dimensions,
-        metric: field.metric,
-        indexType: field.indexType
-      });
-    }
-  }
-}
-async function syncEmbeddingsBatchForKind(args, schema, items) {
-  const { graphId, nodeKind, backend } = args;
-  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
-    return;
-  }
-  const embeddingFields = getEmbeddingFields(schema);
-  if (embeddingFields.length === 0) {
-    return;
-  }
-  for (const field of embeddingFields) {
-    const rows = [];
-    const deletionIds = [];
-    for (const item of items) {
-      const value = readOwnProperty(item.props, field.fieldPath);
-      if (isValidEmbeddingValue(value)) {
-        rows.push({ nodeId: item.nodeId, embedding: value });
-      } else if (value === void 0) {
-        deletionIds.push(item.nodeId);
-      }
-    }
-    if (rows.length > 0) {
-      if (backend.upsertEmbeddingBatch === void 0) {
-        for (const row of rows) {
-          await backend.upsertEmbedding({
-            graphId,
-            nodeKind,
-            nodeId: row.nodeId,
-            fieldPath: field.fieldPath,
-            embedding: row.embedding,
-            dimensions: field.dimensions,
-            metric: field.metric,
-            indexType: field.indexType
-          });
-        }
-      } else {
-        await backend.upsertEmbeddingBatch({
-          graphId,
-          nodeKind,
-          fieldPath: field.fieldPath,
-          dimensions: field.dimensions,
-          metric: field.metric,
-          indexType: field.indexType,
-          rows
-        });
-      }
-    }
-    if (deletionIds.length > 0 && backend.deleteEmbeddingBatch !== void 0) {
-      await backend.deleteEmbeddingBatch({
-        graphId,
-        nodeKind,
-        nodeIds: deletionIds,
-        fieldPath: field.fieldPath,
-        dimensions: field.dimensions,
-        metric: field.metric,
-        indexType: field.indexType
-      });
-    } else {
-      for (const nodeId of deletionIds) {
-        await backend.deleteEmbedding({
-          graphId,
-          nodeKind,
-          nodeId,
-          fieldPath: field.fieldPath,
-          dimensions: field.dimensions,
-          metric: field.metric,
-          indexType: field.indexType
-        });
-      }
-    }
-  }
-}
-async function deleteNodeEmbeddings(ctx, schema) {
-  const { backend } = ctx;
-  if (!backend.deleteEmbedding) {
-    return;
-  }
-  const embeddingFields = getEmbeddingFields(schema);
-  if (embeddingFields.length === 0) {
-    return;
-  }
-  for (const field of embeddingFields) {
-    await backend.deleteEmbedding({
-      graphId: ctx.graphId,
-      nodeKind: ctx.nodeKind,
-      nodeId: ctx.nodeId,
-      fieldPath: field.fieldPath,
-      dimensions: field.dimensions,
-      metric: field.metric,
-      indexType: field.indexType
-    });
-  }
-}
-function isValidEmbeddingValue(value) {
-  if (!Array.isArray(value)) {
-    return false;
-  }
-  return value.every((n) => typeof n === "number" && Number.isFinite(n));
-}
-
-// src/store/fulltext-sync.ts
-var FIELD_SEPARATOR = "\n";
-function resolveCombinedLanguage(fields) {
-  return fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
-}
-function computeFulltextContent(schema, props) {
-  const searchableFields = getSearchableFields(schema);
-  if (searchableFields.length === 0) return void 0;
-  const parts = [];
-  for (const field of searchableFields) {
-    const value = readOwnProperty(props, field.fieldPath);
-    if (typeof value === "string" && value.length > 0) {
-      parts.push(value);
-    }
-  }
-  if (parts.length === 0) return void 0;
-  return {
-    content: parts.join(FIELD_SEPARATOR),
-    language: resolveCombinedLanguage(searchableFields)
-  };
-}
-async function syncFulltext(ctx, schema, props) {
-  const { backend } = ctx;
-  if (!backend.upsertFulltext || !backend.deleteFulltext) {
-    return;
-  }
-  const computed = computeFulltextContent(schema, props);
-  if (computed !== void 0) {
-    await backend.upsertFulltext({
-      graphId: ctx.graphId,
-      nodeKind: ctx.nodeKind,
-      nodeId: ctx.nodeId,
-      content: computed.content,
-      language: computed.language
-    });
-    return;
-  }
-  if (getSearchableFields(schema).length === 0) return;
-  await backend.deleteFulltext({
-    graphId: ctx.graphId,
-    nodeKind: ctx.nodeKind,
-    nodeId: ctx.nodeId
-  });
-}
-async function syncFulltextBatchForKind(args, schema, items) {
-  const { graphId, nodeKind, backend } = args;
-  if (!backend.upsertFulltext || !backend.deleteFulltext) {
-    return;
-  }
-  const rows = [];
-  const emptyContentIds = [];
-  const hasSearchableFields = getSearchableFields(schema).length > 0;
-  for (const item of items) {
-    const computed = computeFulltextContent(schema, item.props);
-    if (computed !== void 0) {
-      rows.push({
-        nodeId: item.nodeId,
-        content: computed.content,
-        language: computed.language
-      });
-    } else if (hasSearchableFields) {
-      emptyContentIds.push(item.nodeId);
-    }
-  }
-  if (rows.length > 0) {
-    if (backend.upsertFulltextBatch === void 0) {
-      for (const row of rows) {
-        await backend.upsertFulltext({
-          graphId,
-          nodeKind,
-          nodeId: row.nodeId,
-          content: row.content,
-          language: row.language
-        });
-      }
-    } else {
-      await backend.upsertFulltextBatch({ graphId, nodeKind, rows });
-    }
-  }
-  if (emptyContentIds.length > 0) {
-    if (backend.deleteFulltextBatch === void 0) {
-      for (const nodeId of emptyContentIds) {
-        await backend.deleteFulltext({ graphId, nodeKind, nodeId });
-      }
-    } else {
-      await backend.deleteFulltextBatch({
-        graphId,
-        nodeKind,
-        nodeIds: emptyContentIds
-      });
-    }
-  }
-}
-async function deleteNodeFulltext(ctx, schema) {
-  const { backend } = ctx;
-  if (!backend.deleteFulltext) {
-    return;
-  }
-  if (getSearchableFields(schema).length === 0) {
-    return;
-  }
-  await backend.deleteFulltext({
-    graphId: ctx.graphId,
-    nodeKind: ctx.nodeKind,
-    nodeId: ctx.nodeId
-  });
-}
-
-// src/store/uniqueness.ts
-function createUniquenessContext(graphId, registry, backend) {
-  return { graphId, registry, backend };
-}
-function nodeIdentityKey(reference) {
-  return encodeTupleKey([reference.kind, reference.id]);
-}
-function proposedUniqueClaims(ctx, upserts) {
-  const claims = [];
-  const claimsByCheckedKind = /* @__PURE__ */ new Map();
-  const claimsByOwnKind = /* @__PURE__ */ new Map();
-  const orderedConstraints = [];
-  const seenConstraints = /* @__PURE__ */ new Set();
-  for (const upsert of upserts) {
-    for (const constraint of upsert.constraints) {
-      if (seenConstraints.has(constraint)) continue;
-      seenConstraints.add(constraint);
-      orderedConstraints.push(constraint);
-    }
-  }
-  for (const constraint of orderedConstraints) {
-    for (const upsert of upserts) {
-      if (!upsert.constraints.includes(constraint)) continue;
-      if (!checkWherePredicate(constraint, upsert.props)) continue;
-      const claim = {
-        kind: upsert.kind,
-        id: upsert.id,
-        constraint,
-        key: computeUniqueKey(
-          upsert.props,
-          constraint.fields,
-          constraint.collation
-        ),
-        kindsToCheck: getKindsForUniquenessCheck(
-          upsert.kind,
-          constraint.scope,
-          ctx.registry
-        )
-      };
-      const identity = nodeIdentityKey(claim);
-      const candidateGroups = [
-        claimsByCheckedKind.get(
-          encodeTupleKey([constraint.name, claim.key, claim.kind])
-        ) ?? [],
-        ...claim.kindsToCheck.map(
-          (kind) => claimsByOwnKind.get(
-            encodeTupleKey([constraint.name, claim.key, kind])
-          ) ?? []
-        )
-      ];
-      const collision = candidateGroups.flat().find((existing) => nodeIdentityKey(existing) !== identity);
-      if (collision !== void 0) {
-        throw new UniquenessError({
-          constraintName: constraint.name,
-          kind: collision.kind,
-          existingId: collision.id,
-          newId: upsert.id,
-          fields: constraint.fields
-        });
-      }
-      claims.push(claim);
-      const ownKindKey = encodeTupleKey([
-        constraint.name,
-        claim.key,
-        claim.kind
-      ]);
-      const sameKindClaims = claimsByOwnKind.get(ownKindKey);
-      if (sameKindClaims === void 0) {
-        claimsByOwnKind.set(ownKindKey, [claim]);
-      } else {
-        sameKindClaims.push(claim);
-      }
-      for (const kind of claim.kindsToCheck) {
-        const checkedKindKey = encodeTupleKey([
-          constraint.name,
-          claim.key,
-          kind
-        ]);
-        const sameDomainClaims = claimsByCheckedKind.get(checkedKindKey);
-        if (sameDomainClaims === void 0) {
-          claimsByCheckedKind.set(checkedKindKey, [claim]);
-        } else {
-          sameDomainClaims.push(claim);
-        }
-      }
-    }
-  }
-  return claims;
-}
-function groupUniqueClaimsForBatchProbe(claims) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const claim of claims) {
-    for (const nodeKind of claim.kindsToCheck) {
-      const groupKey = encodeTupleKey([nodeKind, claim.constraint.name]);
-      const existing = groups.get(groupKey);
-      if (existing === void 0) {
-        groups.set(groupKey, {
-          nodeKind,
-          constraintName: claim.constraint.name,
-          claimsByKey: /* @__PURE__ */ new Map([[claim.key, claim]])
-        });
-        continue;
-      }
-      existing.claimsByKey.set(claim.key, claim);
-    }
-  }
-  return [...groups.values()];
-}
-async function validateResolvedNodeUniqueness(ctx, upserts, releases = []) {
-  const checkUniqueBatch = ctx.backend.checkUniqueBatch;
-  if (checkUniqueBatch === void 0) {
-    throw new ConfigurationError(
-      "Resolved node writes require batched uniqueness probes",
-      { code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED" }
-    );
-  }
-  const claims = proposedUniqueClaims(ctx, upserts);
-  if (claims.length === 0) return;
-  const affectedOwners = new Set(
-    [...upserts, ...releases].map((reference) => nodeIdentityKey(reference))
-  );
-  for (const group of groupUniqueClaimsForBatchProbe(claims)) {
-    const existingRows = await checkUniqueBatch({
-      graphId: ctx.graphId,
-      nodeKind: group.nodeKind,
-      constraintName: group.constraintName,
-      keys: [...group.claimsByKey.keys()]
-    });
-    for (const existing of existingRows) {
-      if (affectedOwners.has(
-        nodeIdentityKey({
-          kind: existing.concrete_kind,
-          id: existing.node_id
-        })
-      )) {
-        continue;
-      }
-      const claim = group.claimsByKey.get(existing.key);
-      if (claim === void 0) continue;
-      throw new UniquenessError({
-        constraintName: group.constraintName,
-        kind: group.nodeKind,
-        existingId: existing.node_id,
-        newId: claim.id,
-        fields: claim.constraint.fields
-      });
-    }
-  }
-}
-async function prepareResolvedNodeUniqueness(ctx, upserts, releases) {
-  const hardDeleteUniquesByNodeIds = ctx.backend.hardDeleteUniquesByNodeIds;
-  if (ctx.backend.checkUniqueBatch === void 0 || ctx.backend.insertUniqueBatch === void 0 || hardDeleteUniquesByNodeIds === void 0) {
-    throw new ConfigurationError(
-      "Resolved node writes require batched uniqueness operations",
-      { code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED" }
-    );
-  }
-  await validateResolvedNodeUniqueness(ctx, upserts, releases);
-  const idsByKind = /* @__PURE__ */ new Map();
-  for (const reference of [...upserts, ...releases]) {
-    const ids = idsByKind.get(reference.kind) ?? /* @__PURE__ */ new Set();
-    ids.add(reference.id);
-    idsByKind.set(reference.kind, ids);
-  }
-  for (const [concreteKind, nodeIds] of idsByKind) {
-    await hardDeleteUniquesByNodeIds({
-      graphId: ctx.graphId,
-      concreteKind,
-      nodeIds: [...nodeIds]
-    });
-  }
-}
-async function applyResolvedNodeUniqueness(ctx, upserts, releases, apply) {
-  await prepareResolvedNodeUniqueness(ctx, upserts, releases);
-  const result = await apply();
-  await insertUniquenessEntriesBatch(ctx, upserts);
-  return result;
-}
-async function probeUniqueKey(ctx, kind, id, constraint, key) {
-  const kindsToCheck = getKindsForUniquenessCheck(
-    kind,
-    constraint.scope,
-    ctx.registry
-  );
-  let heldByThisNode = false;
-  for (const kindToCheck of kindsToCheck) {
-    const existing = await ctx.backend.checkUnique({
-      graphId: ctx.graphId,
-      nodeKind: kindToCheck,
-      constraintName: constraint.name,
-      key
-    });
-    if (existing === void 0) continue;
-    if (existing.node_id !== id) {
-      throw new UniquenessError({
-        constraintName: constraint.name,
-        kind: kindToCheck,
-        existingId: existing.node_id,
-        newId: id,
-        fields: constraint.fields
-      });
-    }
-    if (kindToCheck === kind) heldByThisNode = true;
-  }
-  return heldByThisNode;
-}
-async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
-    }
-    await probeUniqueKey(
-      ctx,
-      kind,
-      id,
-      constraint,
-      computeUniqueKey(props, constraint.fields, constraint.collation)
-    );
-  }
-}
-async function insertUniquenessEntries(ctx, kind, id, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
-    }
-    const key = computeUniqueKey(
-      props,
-      constraint.fields,
-      constraint.collation
-    );
-    await ctx.backend.insertUnique({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      constraintName: constraint.name,
-      key,
-      nodeId: id,
-      concreteKind: kind
-    });
-  }
-}
-async function insertUniquenessEntriesBatch(ctx, items) {
-  const entries = [];
-  for (const item of items) {
-    for (const constraint of item.constraints) {
-      if (!checkWherePredicate(constraint, item.props)) {
-        continue;
-      }
-      entries.push({
-        graphId: ctx.graphId,
-        nodeKind: item.kind,
-        constraintName: constraint.name,
-        key: computeUniqueKey(
-          item.props,
-          constraint.fields,
-          constraint.collation
-        ),
-        nodeId: item.id,
-        concreteKind: item.kind
-      });
-    }
-  }
-  if (entries.length === 0) return;
-  if (ctx.backend.insertUniqueBatch !== void 0) {
-    await ctx.backend.insertUniqueBatch(entries);
-    return;
-  }
-  for (const entry of entries) {
-    await ctx.backend.insertUnique(entry);
-  }
-}
-async function deleteUniquenessEntries(ctx, kind, props, constraints) {
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) {
-      continue;
-    }
-    const key = computeUniqueKey(
-      props,
-      constraint.fields,
-      constraint.collation
-    );
-    await ctx.backend.deleteUnique({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      constraintName: constraint.name,
-      key
-    });
-  }
-}
-async function planUniquenessUpdate(ctx, kind, id, oldProps, newProps, constraints) {
-  const pending = [];
-  for (const constraint of constraints) {
-    const oldApplies = checkWherePredicate(constraint, oldProps);
-    const newApplies = checkWherePredicate(constraint, newProps);
-    const oldKey = oldApplies ? computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
-    const newKey = newApplies ? computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
-    if (!oldApplies && !newApplies) {
-      continue;
-    }
-    if (oldApplies && newApplies && oldKey === newKey) {
-      continue;
-    }
-    const alreadyHeld = newKey === void 0 ? false : await probeUniqueKey(ctx, kind, id, constraint, newKey);
-    pending.push({
-      constraintName: constraint.name,
-      release: oldKey,
-      claim: alreadyHeld ? void 0 : newKey
-    });
-  }
-  return pending;
-}
-async function planUniquenessReinsert(ctx, kind, id, props, constraints) {
-  const pending = [];
-  for (const constraint of constraints) {
-    if (!checkWherePredicate(constraint, props)) continue;
-    const key = computeUniqueKey(
-      props,
-      constraint.fields,
-      constraint.collation
-    );
-    const alreadyHeld = await probeUniqueKey(ctx, kind, id, constraint, key);
-    pending.push({
-      constraintName: constraint.name,
-      release: void 0,
-      claim: alreadyHeld ? void 0 : key
-    });
-  }
-  return pending;
-}
-async function releaseUniqueKeys(ctx, kind, keys) {
-  for (const entry of keys) {
-    await ctx.backend.deleteUnique({
-      graphId: ctx.graphId,
-      nodeKind: kind,
-      constraintName: entry.constraintName,
-      key: entry.key
-    });
-  }
-}
-async function claimUniqueKeysThen(ctx, kind, id, plan, gatedWrite) {
-  const claimed = [];
-  try {
-    for (const mutation of plan) {
-      if (mutation.claim === void 0) continue;
-      await ctx.backend.insertUnique({
-        graphId: ctx.graphId,
-        nodeKind: kind,
-        constraintName: mutation.constraintName,
-        key: mutation.claim,
-        nodeId: id,
-        concreteKind: kind
-      });
-      claimed.push({
-        constraintName: mutation.constraintName,
-        key: mutation.claim
-      });
-    }
-    return await gatedWrite();
-  } catch (error) {
-    await releaseUniqueKeys(ctx, kind, claimed);
-    throw error;
-  }
-}
-async function withUniquenessTransition(ctx, kind, id, plan, gatedWrite) {
-  const result = await claimUniqueKeysThen(ctx, kind, id, plan, gatedWrite);
-  await releaseUniqueKeys(
-    ctx,
-    kind,
-    plan.flatMap(
-      (mutation) => mutation.release === void 0 ? [] : [{ constraintName: mutation.constraintName, key: mutation.release }]
-    )
-  );
-  return result;
-}
-
-// src/store/operations/node-write-pipeline.ts
-function createNodeWriteContext(graphId, registry, lock) {
-  return { graphId, registry, lock };
-}
-function uniquenessContext(ctx, backend) {
-  return createUniquenessContext(ctx.graphId, ctx.registry, backend);
-}
-function nodeSyncContext(ctx, kind, id, backend) {
-  return { graphId: ctx.graphId, nodeKind: kind, nodeId: id, backend };
-}
-async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
-  if (policy?.enforceDeleteBehavior === false) return;
-  const behavior = args.onDelete ?? "restrict";
-  const connectedEdges = await backend.findEdgesConnectedTo({
-    graphId: ctx.graphId,
-    nodeKind: args.kind,
-    nodeId: args.id
-  });
-  if (connectedEdges.length === 0) return;
-  switch (behavior) {
-    case "restrict": {
-      throw new RestrictedDeleteError({
-        nodeKind: args.kind,
-        nodeId: args.id,
-        edgeCount: connectedEdges.length,
-        edgeKinds: [...new Set(connectedEdges.map((edge) => edge.kind))]
-      });
-    }
-    case "cascade":
-    case "disconnect": {
-      const batchDelete = args.mode === "hard" ? backend.hardDeleteEdgesBatch : backend.deleteEdgesBatch;
-      if (batchDelete !== void 0) {
-        await batchDelete({
-          graphId: ctx.graphId,
-          ids: connectedEdges.map((edge) => edge.id)
-        });
-        break;
-      }
-      for (const edge of connectedEdges) {
-        await (args.mode === "hard" ? backend.hardDeleteEdge({ graphId: ctx.graphId, id: edge.id }) : backend.deleteEdge({ graphId: ctx.graphId, id: edge.id }));
-      }
-      break;
-    }
-  }
-}
-async function applyNodeInsertSideEffects(ctx, args, backend) {
-  await insertUniquenessEntries(
-    uniquenessContext(ctx, backend),
-    args.kind,
-    args.id,
-    args.props,
-    args.uniqueConstraints
-  );
-  await Promise.all([
-    syncEmbeddings(
-      nodeSyncContext(ctx, args.kind, args.id, backend),
-      args.schema,
-      args.props
-    ),
-    syncFulltext(
-      nodeSyncContext(ctx, args.kind, args.id, backend),
-      args.schema,
-      args.props
-    )
-  ]);
-}
-async function applyNodeInsertSideEffectsBatch(ctx, items, backend) {
-  if (items.length === 0) return;
-  await insertUniquenessEntriesBatch(
-    uniquenessContext(ctx, backend),
-    items.map((item) => ({
-      kind: item.kind,
-      id: item.id,
-      props: item.props,
-      constraints: item.uniqueConstraints
-    }))
-  );
-  const byKind = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const group = byKind.get(item.kind) ?? { schema: item.schema, rows: [] };
-    group.rows.push({ nodeId: item.id, props: item.props });
-    byKind.set(item.kind, group);
-  }
-  await Promise.all(
-    [...byKind.entries()].flatMap(([kind, group]) => {
-      const syncArguments = { graphId: ctx.graphId, nodeKind: kind, backend };
-      return [
-        syncEmbeddingsBatchForKind(syncArguments, group.schema, group.rows),
-        syncFulltextBatchForKind(syncArguments, group.schema, group.rows)
-      ];
-    })
-  );
-}
-function parseRowProps(row) {
-  return rowPropsToObject(row.props);
-}
-async function planNodeUpdateUniqueness(ctx, args, backend) {
-  const { kind, id } = args.existing;
-  if (args.existing.deleted_at !== void 0) {
-    return planUniquenessReinsert(
-      uniquenessContext(ctx, backend),
-      kind,
-      id,
-      args.validatedProps,
-      args.uniqueConstraints
-    );
-  }
-  return planUniquenessUpdate(
-    uniquenessContext(ctx, backend),
-    kind,
-    id,
-    parseRowProps(args.existing),
-    args.validatedProps,
-    args.uniqueConstraints
-  );
-}
-async function applyNodeUpdate(ctx, args, backend) {
-  const { kind, id } = args.existing;
-  const plan = await planNodeUpdateUniqueness(
-    ctx,
-    {
-      existing: args.existing,
-      validatedProps: args.validatedProps,
-      uniqueConstraints: args.uniqueConstraints
-    },
-    backend
-  );
-  const updateParams = {
-    graphId: ctx.graphId,
-    kind,
-    id,
-    props: args.validatedProps,
-    incrementVersion: true
-  };
-  if (args.validFrom !== void 0) updateParams.validFrom = args.validFrom;
-  if (args.expectedValidFrom !== void 0) {
-    updateParams.expectedValidFrom = args.expectedValidFrom;
-  }
-  if (args.clearDeleted) updateParams.clearDeleted = true;
-  const row = await withUniquenessTransition(
-    uniquenessContext(ctx, backend),
-    kind,
-    id,
-    plan,
-    () => backend.updateNode({
-      ...updateParams,
-      ...args.clearValidTo === true ? { clearValidTo: true } : args.validTo === void 0 ? {} : { validTo: args.validTo }
-    })
-  );
-  await Promise.all([
-    syncEmbeddings(
-      nodeSyncContext(ctx, kind, id, backend),
-      args.schema,
-      args.validatedProps
-    ),
-    syncFulltext(
-      nodeSyncContext(ctx, kind, id, backend),
-      args.schema,
-      args.validatedProps
-    )
-  ]);
-  return row;
-}
-async function applyNodeSoftDelete(ctx, args, backend, policy) {
-  const { kind, id } = args.existing;
-  await enforceNodeDeleteBehavior(
-    ctx,
-    { kind, id, mode: "soft", onDelete: args.onDelete },
-    backend,
-    policy
-  );
-  await backend.deleteNode({
-    graphId: ctx.graphId,
-    kind,
-    id
-  });
-  await deleteUniquenessEntries(
-    uniquenessContext(ctx, backend),
-    kind,
-    parseRowProps(args.existing),
-    args.uniqueConstraints
-  );
-  await deleteNodeEmbeddings(
-    nodeSyncContext(ctx, kind, id, backend),
-    args.schema
-  );
-  await deleteNodeFulltext(
-    nodeSyncContext(ctx, kind, id, backend),
-    args.schema
-  );
-}
-async function applyNodeHardDelete(ctx, args, backend) {
-  await enforceNodeDeleteBehavior(
-    ctx,
-    { kind: args.kind, id: args.id, mode: "hard", onDelete: args.onDelete },
-    backend
-  );
-  await backend.hardDeleteNode({
-    graphId: ctx.graphId,
-    kind: args.kind,
-    id: args.id
-  });
-  await deleteNodeEmbeddings(
-    nodeSyncContext(ctx, args.kind, args.id, backend),
-    args.schema
-  );
-}
-async function applyNodeResurrect(ctx, args, backend) {
-  const { kind, id } = args.existing;
-  const props = parseRowProps(args.existing);
-  const plan = await planUniquenessReinsert(
-    uniquenessContext(ctx, backend),
-    kind,
-    id,
-    props,
-    args.uniqueConstraints
-  );
-  const row = await withUniquenessTransition(
-    uniquenessContext(ctx, backend),
-    kind,
-    id,
-    plan,
-    () => backend.updateNode({
-      graphId: ctx.graphId,
-      kind,
-      id,
-      props,
-      incrementVersion: true,
-      clearDeleted: true
-    })
-  );
-  await Promise.all([
-    syncEmbeddings(nodeSyncContext(ctx, kind, id, backend), args.schema, props),
-    syncFulltext(nodeSyncContext(ctx, kind, id, backend), args.schema, props)
-  ]);
-  return row;
-}
-
-export { AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, STORE_RUNTIME, TRANSACTION_RUNTIME, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, applyResolvedNodeUniqueness, checkUniquenessConstraints, computeFulltextContent, createNodeWriteContext, createUniquenessContext, getEmbeddingFields, storeBackend, storeRuntime, transactionBackend, transactionNodeOperationHookRunner, validateResolvedNodeUniqueness };
-//# sourceMappingURL=chunk-I4GAZH5Z.js.map
-//# sourceMappingURL=chunk-I4GAZH5Z.js.map