@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/chunk-4DKY6RIU.js

@@ -0,0 +1,1253 @@
+import { purgeEdgeClaims } from './chunk-NGQDGL5X.js';
+import { validateNodeProps, constraintFenceRefusal } from './chunk-VAAC7L57.js';
+import { canonicalEqual } from './chunk-QG5VEOKX.js';
+import { missingRequiredExtras, requireExtras } from './chunk-XORONCV3.js';
+import { UNIQUE_SIDECAR_BATCH, rowPropsToObject, bindExtraIfReachable } from './chunk-LKZDQ2B4.js';
+import { uniquenessClaimTarget, DISJOINT_CONSTRAINT_NAME, disjointnessClaimAxis, checkWherePredicate, computeUniqueKey, uniquenessProbeKinds, isSameClaimOwner, claimOwnerKey, compareClaimTargets, encodeTupleKey } from './chunk-RVUL2HXY.js';
+import { assertsStoredLowerBound } from './chunk-K46SDNQD.js';
+import { typeGraphGlobalSymbol } from './chunk-7QFRK6PU.js';
+import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-PC2UBAUB.js';
+import { ConfigurationError, ValidationError, UniquenessError, RestrictedDeleteError, DisjointError } from './chunk-YDEJQWOL.js';
+import { readOwnProperty, requireDefined } 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/claims/sites.ts
+function disjointnessSites(registry, kind) {
+  return registry.getDisjointKinds(kind).map((otherKind) => ({
+    axis: disjointnessClaimAxis(kind, otherKind, registry),
+    constraintName: DISJOINT_CONSTRAINT_NAME,
+    needsLockFence: true,
+    placement: "pre-insert",
+    refusalReason: "nodeDisjointness",
+    refusal: { kind: "disjointness", ownKind: kind, otherKind }
+  }));
+}
+function nodeClaimSites(registry, kind, uniqueConstraints, operation) {
+  const uniqueness = uniqueConstraints.map((constraint) => {
+    const target = uniquenessClaimTarget(kind, constraint.scope, registry);
+    return {
+      axis: target.axis,
+      constraintName: constraint.name,
+      needsLockFence: target.crossKind,
+      placement: operation !== "create" || target.crossKind ? "pre-insert" : "post-insert",
+      refusalReason: target.crossKind ? "nodeUniquenessScope" : "nodeUniquenessClaim",
+      refusal: { kind: "uniqueness", constraint }
+    };
+  });
+  return operation === "update" ? uniqueness : [...disjointnessSites(registry, kind), ...uniqueness];
+}
+
+// src/store/claims/node-claims.ts
+function createUniquenessContext(graphId, registry, backend, uniqueSidecarBatch) {
+  return { graphId, registry, backend, uniqueSidecarBatch };
+}
+function claimKeyFor(refusal, id, props) {
+  if (refusal.kind === "disjointness") return id;
+  return checkWherePredicate(refusal.constraint, props) ? computeUniqueKey(
+    props,
+    refusal.constraint.fields,
+    refusal.constraint.collation
+  ) : void 0;
+}
+function nodeClaimEntries(registry, kind, id, props, constraints, operation) {
+  return nodeClaimSites(registry, kind, constraints, operation).flatMap(
+    (site) => {
+      const key = claimKeyFor(site.refusal, id, props);
+      return key === void 0 ? [] : [
+        {
+          axis: site.axis,
+          constraintName: site.constraintName,
+          key,
+          placement: site.placement,
+          refusalReason: site.refusalReason,
+          refusal: site.refusal
+        }
+      ];
+    }
+  );
+}
+function mapClaimRefusal(error, entries) {
+  const owed = entries.find(
+    (entry) => entry.refusal.kind === "disjointness" && entry.constraintName === error.details.constraintName && entry.key === error.details.newId && (error.details.axis === void 0 || entry.axis === error.details.axis)
+  );
+  if (owed === void 0) throw error;
+  throw new DisjointError(
+    {
+      nodeId: error.details.newId,
+      attemptedKind: owed.refusal.ownKind,
+      conflictingKind: error.details.kind
+    },
+    { cause: error }
+  );
+}
+async function issuingClaims(entries, issue) {
+  try {
+    await issue();
+  } catch (error) {
+    if (error instanceof UniquenessError) mapClaimRefusal(error, entries);
+    throw error;
+  }
+}
+function claimFenceRefusal(ctx, backend, entries) {
+  const gating = entries.find((entry) => entry.placement === "pre-insert");
+  if (gating === void 0) return void 0;
+  return constraintFenceRefusal(ctx, backend, gating.refusalReason);
+}
+function isUniquenessClaimEntry(entry) {
+  return entry.refusal.kind === "uniqueness";
+}
+async function probeUniqueKey(ctx, kind, id, entry) {
+  const mine = { concreteKind: kind, nodeId: id };
+  let heldByThisNode = false;
+  for (const kindToCheck of uniquenessProbeKinds(
+    kind,
+    entry.refusal.constraint.scope,
+    ctx.registry
+  )) {
+    const existing = await ctx.backend.checkUnique({
+      graphId: ctx.graphId,
+      nodeKind: kindToCheck,
+      constraintName: entry.constraintName,
+      key: entry.key
+    });
+    if (existing === void 0) continue;
+    if (!isSameClaimOwner(
+      { concreteKind: existing.concrete_kind, nodeId: existing.node_id },
+      mine
+    )) {
+      throw new UniquenessError({
+        constraintName: entry.constraintName,
+        kind: existing.concrete_kind,
+        existingId: existing.node_id,
+        newId: id,
+        fields: entry.refusal.constraint.fields
+      });
+    }
+    if (kindToCheck === entry.axis) heldByThisNode = true;
+  }
+  return heldByThisNode;
+}
+async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
+  for (const entry of nodeClaimEntries(
+    ctx.registry,
+    kind,
+    id,
+    props,
+    constraints,
+    "create"
+  )) {
+    if (isUniquenessClaimEntry(entry))
+      await probeUniqueKey(ctx, kind, id, entry);
+  }
+}
+function claimTarget(graphId, entry) {
+  return {
+    relation: "uniques",
+    graphId,
+    axis: entry.axis,
+    constraintName: entry.constraintName,
+    key: entry.key
+  };
+}
+function claimInsertParams(graphId, claim) {
+  return {
+    graphId,
+    nodeKind: claim.entry.axis,
+    constraintName: claim.entry.constraintName,
+    key: claim.entry.key,
+    nodeId: claim.item.id,
+    concreteKind: claim.item.kind
+  };
+}
+async function issueClaimsIndividually(ctx, claims, onIssued) {
+  for (const claim of claims) {
+    await issuingClaims(
+      [claim.entry],
+      () => ctx.backend.insertUnique(claimInsertParams(ctx.graphId, claim))
+    );
+    onIssued?.([claim]);
+  }
+}
+async function issueClaimsBatched(ctx, claims, onIssued) {
+  if (claims.length === 0) return;
+  const bound = bindExtraIfReachable(
+    ctx.backend,
+    ctx.uniqueSidecarBatch.extras.insertUniqueBatch,
+    UNIQUE_SIDECAR_BATCH.id
+  );
+  if (bound === void 0) {
+    await issueClaimsIndividually(ctx, claims, onIssued);
+    return;
+  }
+  await issuingClaims(
+    claims.map((claim) => claim.entry),
+    async () => {
+      await bound.insertUniqueBatch(
+        claims.map((claim) => claimInsertParams(ctx.graphId, claim))
+      );
+    }
+  );
+  onIssued?.(claims);
+}
+async function claimGroupThenWrite(ctx, issue, gating, gatedWrite) {
+  const issued = [];
+  try {
+    await issue(ctx, gating, (landed) => {
+      issued.push(...landed);
+    });
+    return await gatedWrite();
+  } catch (error) {
+    for (const claim of issued.toReversed()) {
+      await releaseClaimedUniqueKeys(ctx, claim.item.kind, claim.item.id, [
+        {
+          axis: claim.entry.axis,
+          constraintName: claim.entry.constraintName,
+          key: claim.entry.key
+        }
+      ]);
+    }
+    throw error;
+  }
+}
+async function withNodeCreateClaimsIssuedBy(ctx, items, backend, issue, gatedInsert) {
+  const claimContext = createUniquenessContext(
+    ctx.graphId,
+    ctx.registry,
+    backend,
+    ctx.uniqueSidecarBatch
+  );
+  const claims = items.flatMap(
+    (item) => nodeClaimEntries(
+      ctx.registry,
+      item.kind,
+      item.id,
+      item.props,
+      item.constraints,
+      "create"
+    ).map((entry) => ({
+      item,
+      entry,
+      target: claimTarget(ctx.graphId, entry)
+    }))
+  );
+  const refusal = claimFenceRefusal(
+    ctx,
+    backend,
+    claims.map((claim) => claim.entry)
+  );
+  if (refusal !== void 0) throw refusal;
+  const inPlacement = (placement) => claims.filter((claim) => claim.entry.placement === placement).toSorted(
+    (left, right) => compareClaimTargets(left.target, right.target)
+  );
+  const result = await claimGroupThenWrite(
+    claimContext,
+    issue,
+    inPlacement("pre-insert"),
+    gatedInsert
+  );
+  await issue(claimContext, inPlacement("post-insert"));
+  return result;
+}
+function withNodeCreateClaims(ctx, item, backend, gatedInsert) {
+  return withNodeCreateClaimsIssuedBy(
+    ctx,
+    [item],
+    backend,
+    issueClaimsIndividually,
+    gatedInsert
+  );
+}
+function withNodeCreateClaimsBatch(ctx, items, backend, gatedInsert) {
+  return withNodeCreateClaimsIssuedBy(
+    ctx,
+    items,
+    backend,
+    issueClaimsBatched,
+    gatedInsert
+  );
+}
+function alreadyAppliedRowWrite() {
+  return Promise.resolve(void 0);
+}
+async function deleteUniquenessEntries(ctx, kind, id, props, constraints) {
+  await releaseOwnedUniqueKeys(
+    ctx,
+    kind,
+    id,
+    nodeClaimEntries(ctx.registry, kind, id, props, constraints, "create")
+  );
+}
+async function hardDeleteClaimsByNodeIds(ctx, concreteKind, nodeIds) {
+  await requireDefined(
+    bindExtraIfReachable(
+      ctx.backend,
+      ctx.uniqueSidecarBatch.extras.hardDeleteUniquesByNodeIds,
+      UNIQUE_SIDECAR_BATCH.id
+    )?.hardDeleteUniquesByNodeIds
+  )({
+    graphId: ctx.graphId,
+    concreteKind,
+    nodeIds
+  });
+}
+async function planNodeClaimUpdate(ctx, kind, id, oldProps, newProps, constraints) {
+  const oldKeys = new Map(
+    nodeClaimEntries(
+      ctx.registry,
+      kind,
+      id,
+      oldProps,
+      constraints,
+      "update"
+    ).map((entry) => [entry.constraintName, entry.key])
+  );
+  const newEntries = new Map(
+    nodeClaimEntries(ctx.registry, kind, id, newProps, constraints, "update").filter(
+      (entry) => isUniquenessClaimEntry(entry)
+    ).map((entry) => [entry.constraintName, entry])
+  );
+  const pending = [];
+  for (const constraint of constraints) {
+    const oldKey = oldKeys.get(constraint.name);
+    const newEntry = newEntries.get(constraint.name);
+    if (oldKey === void 0 && newEntry === void 0) continue;
+    if (oldKey !== void 0 && oldKey === newEntry?.key) continue;
+    const alreadyHeld = newEntry === void 0 ? false : await probeUniqueKey(ctx, kind, id, newEntry);
+    pending.push({
+      constraintName: constraint.name,
+      release: oldKey,
+      claim: newEntry === void 0 || alreadyHeld ? void 0 : newEntry
+    });
+  }
+  return pending;
+}
+async function planNodeClaimReinsert(ctx, kind, id, props, constraints) {
+  const pending = [];
+  for (const entry of nodeClaimEntries(
+    ctx.registry,
+    kind,
+    id,
+    props,
+    constraints,
+    "resurrect"
+  )) {
+    const alreadyHeld = isUniquenessClaimEntry(entry) ? await probeUniqueKey(ctx, kind, id, entry) : false;
+    pending.push({
+      constraintName: entry.constraintName,
+      release: void 0,
+      claim: alreadyHeld ? void 0 : entry
+    });
+  }
+  return pending;
+}
+async function releaseOwnedUniqueKeys(ctx, kind, id, keys) {
+  for (const entry of keys) {
+    await ctx.backend.deleteUnique({
+      graphId: ctx.graphId,
+      constraintName: entry.constraintName,
+      key: entry.key,
+      concreteKind: kind,
+      nodeId: id
+    });
+  }
+}
+async function releaseClaimedUniqueKeys(ctx, kind, id, keys) {
+  for (const entry of keys) {
+    await ctx.backend.deleteUnique({
+      graphId: ctx.graphId,
+      nodeKind: entry.axis,
+      constraintName: entry.constraintName,
+      key: entry.key,
+      concreteKind: kind,
+      nodeId: id
+    });
+  }
+}
+async function claimUniqueKeysThen(ctx, kind, id, plan, gatedWrite) {
+  const claimed = [];
+  try {
+    for (const mutation of plan) {
+      const claim = mutation.claim;
+      if (claim === void 0) continue;
+      await issuingClaims(
+        [claim],
+        () => ctx.backend.insertUnique({
+          graphId: ctx.graphId,
+          nodeKind: claim.axis,
+          constraintName: mutation.constraintName,
+          key: claim.key,
+          nodeId: id,
+          concreteKind: kind
+        })
+      );
+      claimed.push({
+        axis: claim.axis,
+        constraintName: mutation.constraintName,
+        key: claim.key
+      });
+    }
+    return await gatedWrite();
+  } catch (error) {
+    await releaseClaimedUniqueKeys(ctx, kind, id, claimed);
+    throw error;
+  }
+}
+async function withNodeClaimTransition(ctx, kind, id, plan, gatedWrite) {
+  const refusal = claimFenceRefusal(
+    ctx,
+    ctx.backend,
+    plan.flatMap(
+      (mutation) => mutation.claim === void 0 ? [] : [mutation.claim]
+    )
+  );
+  if (refusal !== void 0) throw refusal;
+  const result = await claimUniqueKeysThen(ctx, kind, id, plan, gatedWrite);
+  await releaseOwnedUniqueKeys(
+    ctx,
+    kind,
+    id,
+    plan.flatMap(
+      (mutation) => mutation.release === void 0 ? [] : [{ constraintName: mutation.constraintName, key: mutation.release }]
+    )
+  );
+  return result;
+}
+
+// src/store/claims/resolved-node-claims.ts
+function claimRowKey(entry) {
+  return encodeTupleKey([entry.constraintName, entry.key]);
+}
+function claimsCompete(left, right) {
+  return claimRowKey(left.entry) === claimRowKey(right.entry) && (right.probeKinds.includes(left.entry.axis) || left.probeKinds.includes(right.entry.axis));
+}
+function proposedClaimRefusal(incumbent, challenger) {
+  return new UniquenessError({
+    constraintName: challenger.entry.constraintName,
+    kind: incumbent.owner.concreteKind,
+    existingId: incumbent.owner.nodeId,
+    newId: challenger.owner.nodeId,
+    fields: challenger.entry.refusal.constraint.fields
+  });
+}
+function proposedClaims(ctx, upserts) {
+  const accepted = [];
+  for (const upsert of upserts) {
+    const owner = {
+      concreteKind: upsert.kind,
+      nodeId: upsert.id
+    };
+    const entries = nodeClaimEntries(
+      ctx.registry,
+      upsert.kind,
+      upsert.id,
+      { ...upsert.props },
+      upsert.constraints,
+      "create"
+    );
+    for (const entry of entries) {
+      if (!isUniquenessClaimEntry(entry)) continue;
+      const proposal = {
+        owner,
+        entry,
+        probeKinds: uniquenessProbeKinds(
+          upsert.kind,
+          entry.refusal.constraint.scope,
+          ctx.registry
+        )
+      };
+      const incumbent = accepted.find(
+        (candidate) => !isSameClaimOwner(candidate.owner, proposal.owner) && claimsCompete(candidate, proposal)
+      );
+      if (incumbent !== void 0) {
+        throw proposedClaimRefusal(incumbent, proposal);
+      }
+      accepted.push(proposal);
+    }
+  }
+  return accepted;
+}
+function groupClaimsForProbe(claims) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    for (const probeKind of claim.probeKinds) {
+      const groupKey = encodeTupleKey([probeKind, claim.entry.constraintName]);
+      const existing = groups.get(groupKey);
+      if (existing === void 0) {
+        groups.set(groupKey, {
+          probeKind,
+          constraintName: claim.entry.constraintName,
+          claimsByKey: /* @__PURE__ */ new Map([[claim.entry.key, claim]])
+        });
+        continue;
+      }
+      existing.claimsByKey.set(claim.entry.key, claim);
+    }
+  }
+  return [...groups.values()];
+}
+function requireBatchProbe(ctx) {
+  const bound = bindExtraIfReachable(
+    ctx.backend,
+    ctx.uniqueSidecarBatch.extras.checkUniqueBatch,
+    UNIQUE_SIDECAR_BATCH.id
+  );
+  if (bound === void 0) {
+    throw new ConfigurationError(
+      "Resolved node writes require batched uniqueness probes",
+      { code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED" }
+    );
+  }
+  return bound.checkUniqueBatch;
+}
+async function validateResolvedNodeClaims(ctx, upserts, releases = []) {
+  const checkUniqueBatch = requireBatchProbe(ctx);
+  const claims = proposedClaims(ctx, upserts);
+  if (claims.length === 0) return;
+  const affectedOwners = new Set(
+    [...upserts, ...releases].map(
+      (reference) => claimOwnerKey({ concreteKind: reference.kind, nodeId: reference.id })
+    )
+  );
+  for (const group of groupClaimsForProbe(claims)) {
+    const existingRows = await checkUniqueBatch({
+      graphId: ctx.graphId,
+      nodeKind: group.probeKind,
+      constraintName: group.constraintName,
+      keys: [...group.claimsByKey.keys()]
+    });
+    for (const existing of existingRows) {
+      if (affectedOwners.has(
+        claimOwnerKey({
+          concreteKind: existing.concrete_kind,
+          nodeId: existing.node_id
+        })
+      )) {
+        continue;
+      }
+      const claim = group.claimsByKey.get(existing.key);
+      if (claim === void 0) continue;
+      throw new UniquenessError({
+        constraintName: group.constraintName,
+        // The holder's own kind, never `group.probeKind`: that is the claim
+        // AXIS, which a shared scope folds across kinds and which the caller
+        // never wrote. The probe and the fence report the same value.
+        kind: existing.concrete_kind,
+        existingId: existing.node_id,
+        newId: claim.owner.nodeId,
+        fields: claim.entry.refusal.constraint.fields
+      });
+    }
+  }
+}
+function resolvedNodeUniquenessOperationsRefusal() {
+  return new ConfigurationError(
+    "Resolved node writes require batched uniqueness operations",
+    { code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED" }
+  );
+}
+async function prepareResolvedNodeClaims(ctx, upserts, releases) {
+  requireExtras(
+    UNIQUE_SIDECAR_BATCH,
+    ctx.uniqueSidecarBatch,
+    "resolved node write",
+    () => {
+      throw resolvedNodeUniquenessOperationsRefusal();
+    }
+  );
+  const boundHardDelete = bindExtraIfReachable(
+    ctx.backend,
+    ctx.uniqueSidecarBatch.extras.hardDeleteUniquesByNodeIds,
+    UNIQUE_SIDECAR_BATCH.id
+  );
+  if (boundHardDelete === void 0) {
+    throw resolvedNodeUniquenessOperationsRefusal();
+  }
+  const { hardDeleteUniquesByNodeIds } = boundHardDelete;
+  if (bindExtraIfReachable(
+    ctx.backend,
+    ctx.uniqueSidecarBatch.extras.insertUniqueBatch,
+    UNIQUE_SIDECAR_BATCH.id
+  ) === void 0) {
+    throw resolvedNodeUniquenessOperationsRefusal();
+  }
+  await validateResolvedNodeClaims(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 applyResolvedNodeClaims(ctx, backend, upserts, releases, apply) {
+  const claimContext = {
+    graphId: ctx.graphId,
+    registry: ctx.registry,
+    backend,
+    uniqueSidecarBatch: ctx.uniqueSidecarBatch
+  };
+  await prepareResolvedNodeClaims(claimContext, upserts, releases);
+  const result = await apply();
+  await withNodeCreateClaimsBatch(
+    ctx,
+    upserts.map((upsert) => ({
+      kind: upsert.kind,
+      id: upsert.id,
+      props: { ...upsert.props },
+      constraints: upsert.constraints
+    })),
+    backend,
+    alreadyAppliedRowWrite
+  );
+  return result;
+}
+
+// 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/operations/node-write-pipeline.ts
+function createNodeWriteContext(graphId, registry, lock, claimsVerdict, uniqueSidecarBatch) {
+  return { graphId, registry, lock, claimsVerdict, uniqueSidecarBatch };
+}
+function uniquenessContext(ctx, backend) {
+  return createUniquenessContext(
+    ctx.graphId,
+    ctx.registry,
+    backend,
+    ctx.uniqueSidecarBatch
+  );
+}
+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 connectedEdgeIds = connectedEdges.map((edge) => edge.id);
+      const batchDelete = args.mode === "hard" ? backend.hardDeleteEdgesBatch : backend.deleteEdgesBatch;
+      if (batchDelete === void 0) {
+        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 }));
+        }
+      } else {
+        await batchDelete({
+          graphId: ctx.graphId,
+          ids: connectedEdgeIds
+        });
+      }
+      if (args.mode === "hard") {
+        await purgeEdgeClaims(
+          backend,
+          ctx.claimsVerdict(),
+          ctx.graphId,
+          connectedEdgeIds
+        );
+      }
+      break;
+    }
+  }
+}
+async function applyNodeInsertSyncFans(ctx, args, backend) {
+  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 applyNodeInsertSyncFansBatch(ctx, items, backend) {
+  if (items.length === 0) return;
+  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 planNodeClaimReinsert(
+      uniquenessContext(ctx, backend),
+      kind,
+      id,
+      args.validatedProps,
+      args.uniqueConstraints
+    );
+  }
+  return planNodeClaimUpdate(
+    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 (assertsStoredLowerBound(args)) {
+    updateParams.expectedValidFrom = args.expectedValidFrom;
+  }
+  if (args.clearDeleted) updateParams.clearDeleted = true;
+  const row = await withNodeClaimTransition(
+    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,
+    id,
+    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 planNodeClaimReinsert(
+    uniquenessContext(ctx, backend),
+    kind,
+    id,
+    props,
+    args.uniqueConstraints
+  );
+  const row = await withNodeClaimTransition(
+    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;
+}
+async function applyNodeSetUpdate(ctx, args, backend) {
+  const { kind, schema, uniqueConstraints } = args;
+  const updateNodeSet = backend.updateNodeSet;
+  if (updateNodeSet === void 0) {
+    throw new ConfigurationError(
+      "The transaction backend does not support set-based node updates",
+      { code: "SET_UPDATE_UNSUPPORTED", kind }
+    );
+  }
+  if (uniqueConstraints.length > 0 && missingRequiredExtras(
+    UNIQUE_SIDECAR_BATCH,
+    ctx.uniqueSidecarBatch,
+    "set-based node update"
+  ).length > 0) {
+    throw new ConfigurationError(
+      "The transaction backend lacks batched uniqueness operations",
+      { code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED", kind }
+    );
+  }
+  if (getSearchableFields(schema).length > 0 && (backend.upsertFulltext === void 0 || backend.deleteFulltext === void 0 || backend.upsertFulltextBatch === void 0 || backend.deleteFulltextBatch === void 0)) {
+    throw new ConfigurationError(
+      "The transaction backend lacks batched fulltext operations",
+      { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
+    );
+  }
+  if (getEmbeddingFields(schema).length > 0 && (backend.upsertEmbedding === void 0 || backend.deleteEmbedding === void 0 || backend.upsertEmbeddingBatch === void 0 || backend.deleteEmbeddingBatch === void 0)) {
+    throw new ConfigurationError(
+      "The transaction backend lacks batched vector operations",
+      { code: "SET_UPDATE_VECTOR_UNSUPPORTED", kind }
+    );
+  }
+  const result = await updateNodeSet({
+    graphId: ctx.graphId,
+    kind,
+    patch: args.patch,
+    unsetProperties: args.unsetProperties,
+    candidateIds: args.candidateIds,
+    candidateIdColumn: args.candidateIdColumn
+  });
+  if (result.affectedCount === 0) return { affectedCount: 0 };
+  const sidecarItems = result.rows.map((row) => {
+    const props = rowPropsToObject(row.props);
+    const validatedProps = validateNodeProps(schema, props, {
+      kind,
+      operation: "update",
+      id: row.id
+    });
+    if (!canonicalEqual(validatedProps, props)) {
+      throw new ValidationError(
+        `Set update would persist a non-canonical ${kind} row`,
+        {
+          entityType: "node",
+          kind,
+          operation: "update",
+          id: row.id,
+          issues: [
+            {
+              path: "props",
+              message: "The complete row requires schema normalization"
+            }
+          ]
+        }
+      );
+    }
+    return {
+      kind,
+      id: row.id,
+      schema,
+      props: validatedProps,
+      uniqueConstraints
+    };
+  });
+  const claimItems = sidecarItems.map((item) => ({
+    kind: item.kind,
+    id: item.id,
+    props: item.props,
+    constraints: item.uniqueConstraints
+  }));
+  if (uniqueConstraints.length > 0) {
+    if (bindExtraIfReachable(
+      backend,
+      ctx.uniqueSidecarBatch.extras.insertUniqueBatch,
+      UNIQUE_SIDECAR_BATCH.id
+    ) === void 0) {
+      throw new ConfigurationError(
+        "The transaction backend lacks batched uniqueness operations",
+        { code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED", kind }
+      );
+    }
+    await validateResolvedNodeClaims(
+      createUniquenessContext(
+        ctx.graphId,
+        ctx.registry,
+        backend,
+        ctx.uniqueSidecarBatch
+      ),
+      claimItems,
+      []
+    );
+    await hardDeleteClaimsByNodeIds(
+      uniquenessContext(ctx, backend),
+      kind,
+      result.rows.map((row) => row.id)
+    );
+  }
+  await withNodeCreateClaimsBatch(
+    ctx,
+    claimItems,
+    backend,
+    alreadyAppliedRowWrite
+  );
+  await applyNodeInsertSyncFansBatch(ctx, sidecarItems, backend);
+  return { affectedCount: result.affectedCount };
+}
+
+export { AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, STORE_RUNTIME, TRANSACTION_RUNTIME, applyNodeHardDelete, applyNodeInsertSyncFans, applyNodeInsertSyncFansBatch, applyNodeResurrect, applyNodeSetUpdate, applyNodeSoftDelete, applyNodeUpdate, applyResolvedNodeClaims, checkUniquenessConstraints, computeFulltextContent, createNodeWriteContext, createUniquenessContext, getEmbeddingFields, nodeClaimEntries, nodeClaimSites, storeBackend, storeRuntime, transactionBackend, transactionNodeOperationHookRunner, withNodeCreateClaims, withNodeCreateClaimsBatch };
+//# sourceMappingURL=chunk-4DKY6RIU.js.map
+//# sourceMappingURL=chunk-4DKY6RIU.js.map