@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/{chunk-AX6JGVTZ.js → chunk-2CYI5HRH.js}

@@ -1,13 +1,14 @@
-import { createNodeBatchValidationBackend, primeBatchValidationCaches } from './chunk-KF6K7TGH.js';
-import { storeBackend, storeRuntime, applyNodeInsertSideEffectsBatch, applyNodeUpdate, checkUniquenessConstraints, applyNodeInsertSideEffects } from './chunk-I4GAZH5Z.js';
-import { runInWriteTransaction, IDENTITY_IMPORT_PROGRESS, IDENTITY_IMPORT_FAILED_ASSERTION } from './chunk-ZFMCDJGB.js';
-import { encodeTupleKey } from './chunk-S5TERQVW.js';
-import { acquireSerializedStreamLease, snapshotExportContention } from './chunk-UGHG7PGX.js';
-import { isLiveNodeRow, rowPropsToObject } from './chunk-6LN7FIVU.js';
-import { getNodeKinds, getEdgeKinds } from './chunk-HEV35TGT.js';
-import { validateEdgeEndpoints } from './chunk-GLHXM7C4.js';
-import { isCanonicalIsoDate, nowIso, assertWritableValidityWindow, validateOptionalCanonicalIsoDate, assertOrderedValidityWindow } from './chunk-5K2BKEBD.js';
-import { ConfigurationError, ValidationError, ExportStreamCancelledError, ExportStreamIdleTimeoutError, NodeNotFoundError, IdentityContradictionError, DatabaseOperationError, UniquenessError, INVERTED_VALIDITY_WINDOW_CODE, IMMUTABLE_VALIDITY_LOWER_BOUND_CODE } from './chunk-ZLONH2UD.js';
+import { graphOwesClaims, runWritePlan, mixedWritePlan, createNodeBatchValidationSeams, primeBatchValidationCaches, createEdgeBatchValidationBackend, checkDisjointnessConstraint, checkCardinalityConstraint } from './chunk-2GIV5X4P.js';
+import { storeBackend, storeRuntime, checkUniquenessConstraints } from './chunk-VTJVMP4I.js';
+import { edgeCardinalityClaim } from './chunk-YA36ABIL.js';
+import { IDENTITY_IMPORT_PROGRESS, IDENTITY_IMPORT_FAILED_ASSERTION } from './chunk-GVYVGGPJ.js';
+import { constraintFenceRefusal } from './chunk-FX5ZW6PN.js';
+import { acquireSerializedStreamLease, snapshotExportContention } from './chunk-IRPYOHRC.js';
+import { isLiveNodeRow, rowPropsToObject } from './chunk-PALYTHGM.js';
+import { getNodeKinds, getEdgeKinds } from './chunk-DI6VC62F.js';
+import { encodeTupleKey, validateEdgeEndpoints } from './chunk-5LKOVCPP.js';
+import { isCanonicalIsoDate, nowIso, assertWritableValidityWindow, validateOptionalCanonicalIsoDate, assertOrderedValidityWindow } from './chunk-K46SDNQD.js';
+import { ConfigurationError, ValidationError, ExportStreamCancelledError, ExportStreamIdleTimeoutError, NodeNotFoundError, IdentityContradictionError, DatabaseOperationError, UniquenessError, DisjointError, CardinalityError, INVERTED_VALIDITY_WINDOW_CODE, IMMUTABLE_VALIDITY_LOWER_BOUND_CODE } from './chunk-YDEJQWOL.js';
 import { requireDefined, createDataKeyedBag, hasOwnKey } from './chunk-DYATYRY4.js';
 import { z } from 'zod';
 
@@ -238,6 +239,29 @@ var ExportStreamOptionsSchema = ExportOptionsSchema.extend({
   batchSize: z.number().int().positive().default(1e3)
 });
 
+// src/interchange/ingestion-import-target.ts
+var INGESTION_IMPORT_TARGETS = /* @__PURE__ */ new WeakMap();
+function registerIngestionImportTarget(handle, store) {
+  INGESTION_IMPORT_TARGETS.set(handle, store);
+}
+function resolveIngestionImportTarget(target) {
+  const registeredStore = INGESTION_IMPORT_TARGETS.get(target);
+  if (registeredStore !== void 0) return registeredStore;
+  try {
+    storeBackend(target);
+    return target;
+  } catch (error) {
+    throw new ConfigurationError(
+      "Interchange import received an unrecognized ingestion target",
+      { target: "unregistered-ingestion-target" },
+      {
+        cause: error,
+        suggestion: "Pass a Store or the exact handle returned by ingestionBranch() from this TypeGraph installation."
+      }
+    );
+  }
+}
+
 // src/interchange/stream-source.ts
 var EXPORT_STREAM_BACKENDS = /* @__PURE__ */ new WeakMap();
 function markExportStreamBackend(stream, backend) {
@@ -249,7 +273,8 @@ function exportStreamBackend(stream) {
 }
 
 // src/interchange/import.ts
-async function importGraph(store, data, rawOptions) {
+async function importGraph(target, data, rawOptions) {
+  const store = resolveIngestionImportTarget(target);
   const options = ImportOptionsSchema.parse(rawOptions);
   return withImportStreamLease(
     store,
@@ -284,22 +309,34 @@ async function importGraphData(store, data, options) {
   const backend = storeBackend(store);
   const runtime = storeRuntime(store);
   const registry = store.registry;
+  const owedClaimReason = graphOwesClaims(graph, registry);
+  const claimRefusal = owedClaimReason === void 0 ? void 0 : constraintFenceRefusal({ graphId }, backend, owedClaimReason);
+  if (claimRefusal !== void 0) throw claimRefusal;
   const nodeSchemas = buildNodeSchemaMap(graph);
   const edgeSchemas = buildEdgeSchemaMap(graph);
   const importedNodeIds = /* @__PURE__ */ new Set();
-  await runInWriteTransaction(
+  await runWritePlan(
     {
       graphId,
+      registry,
       schemaVersion: store.introspect().schemaVersion,
       historyEnabled: store.historyEnabled,
       revisionTrackingEnabled: store.revisionTrackingEnabled,
-      revisionSchema: store.revisionSchema
+      revisionSchema: store.revisionSchema,
+      // HOW this caller takes position 3. `lockIdentityImportTarget` is
+      // `lockIdentityGraph` on an identity graph and a no-op otherwise, so the
+      // participation below is unconditional and the acquirer owns the
+      // "identity is configured" test, exactly as before the migration.
+      identityLock: (target) => runtime.lockIdentityImportTarget(target)
     },
+    // An import writes node rows AND edge rows in one frame, so it declares the
+    // mixed family explicitly instead of receiving either narrower session.
+    mixedWritePlan(void 0, true),
     backend,
-    async (target, lock) => {
-      await runtime.lockIdentityImportTarget(target);
+    async (session, target, overlaidSession) => {
+      const frame = { session, target, overlaidSession };
       await processNodes(
-        target,
+        frame,
         graphId,
         registry,
         data.nodes,
@@ -307,8 +344,7 @@ async function importGraphData(store, data, options) {
         options,
         result,
         errors,
-        importedNodeIds,
-        lock
+        importedNodeIds
       );
       await runtime.foldImportedIdentityNodes(
         target,
@@ -317,7 +353,7 @@ async function importGraphData(store, data, options) {
         ).map((node) => ({ kind: node.kind, id: node.id }))
       );
       await processEdges(
-        target,
+        frame,
         graphId,
         registry,
         data.edges,
@@ -347,7 +383,8 @@ async function importGraphData(store, data, options) {
     errors
   };
 }
-async function importGraphStream(store, chunks, rawOptions) {
+async function importGraphStream(target, chunks, rawOptions) {
+  const store = resolveIngestionImportTarget(target);
   const options = ImportOptionsSchema.parse(rawOptions);
   const sourceBackend = exportStreamBackend(chunks);
   const targetBackend = storeBackend(store);
@@ -727,12 +764,12 @@ function buildEdgeSchemaMap(graph) {
   }
   return map;
 }
-async function processNodes(backend, graphId, registry, nodes, schemas, options, result, errors, importedNodeIds, lock) {
+async function processNodes(frame, graphId, registry, nodes, schemas, options, result, errors, importedNodeIds) {
   const batchSize = options.batchSize;
   for (let index = 0; index < nodes.length; index += batchSize) {
     const batch = nodes.slice(index, index + batchSize);
     await processNodeSlice(
-      backend,
+      frame,
       graphId,
       registry,
       batch,
@@ -740,8 +777,7 @@ async function processNodes(backend, graphId, registry, nodes, schemas, options,
       options,
       result,
       errors,
-      importedNodeIds,
-      lock
+      importedNodeIds
     );
   }
 }
@@ -775,7 +811,7 @@ function recordNodeOutcome(node, outcome, result, errors, importedNodeIds) {
     }
   }
 }
-async function processNodeSlice(backend, graphId, registry, batch, schemas, options, result, errors, importedNodeIds, lock) {
+async function processNodeSlice(frame, graphId, registry, batch, schemas, options, result, errors, importedNodeIds) {
   const record = (node, outcome) => {
     recordNodeOutcome(node, outcome, result, errors, importedNodeIds);
   };
@@ -834,20 +870,21 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
     });
   }
   const {
-    backend: validationBackend,
+    reads,
+    reader: validationBackend,
     registerPendingNode,
     registerPendingUniqueEntries,
     registerAppliedNodeUpdate,
     seedNodeRow,
     seedUniqueRow
-  } = createNodeBatchValidationBackend(graphId, registry, backend);
+  } = createNodeBatchValidationSeams(graphId, registry, frame.target);
   await primeBatchValidationCaches(
     { graphId, registry },
     candidates.map((candidate) => candidate.draft),
-    backend,
+    frame.target,
     { seedNodeRow, seedUniqueRow }
   );
-  const writeContext = { graphId, registry, lock };
+  const overlaidSession = frame.overlaidSession(reads);
   const accepted = [];
   for (const candidate of candidates) {
     const { node, schemaEntry, props } = candidate;
@@ -886,25 +923,13 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
             record(node, { status: "error", error: updateWindow.error });
             break;
           }
-          const updateError = await updateImportedNode(
-            writeContext,
-            // The pending-aware overlay, not the raw backend: the update's
-            // uniqueness pre-check must see a unique value already reserved by
-            // an unflushed create EARLIER in this slice, so it degrades to a
-            // per-row error exactly as the sequential path does — rather than
-            // claiming the key on the real backend and colliding with that
-            // create at flush (which would throw and roll back the whole
-            // import). Writes still delegate to the real backend.
-            validationBackend,
-            node,
-            {
-              existing,
-              schema: schemaEntry.registration.type.schema,
-              validatedProps: props,
-              uniqueConstraints,
-              windowFence: updateWindow.value
-            }
-          );
+          const updateError = await updateImportedNode(overlaidSession, node, {
+            existing,
+            schema: schemaEntry.registration.type.schema,
+            validatedProps: props,
+            uniqueConstraints,
+            windowFence: updateWindow.value
+          });
           if (updateError === void 0) {
             registerAppliedNodeUpdate(
               node.kind,
@@ -923,44 +948,38 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
       }
       continue;
     }
-    const uniquenessResult = await catchUniquenessError(
-      () => checkUniquenessConstraints(
+    const constraintResult = await catchDeclaredConstraintRefusal(async () => {
+      await checkUniquenessConstraints(
         { graphId, registry, backend: validationBackend },
         node.kind,
         node.id,
         props,
         uniqueConstraints
-      )
-    );
-    if (!uniquenessResult.ok) {
-      record(node, { status: "error", error: uniquenessResult.error });
+      );
+      await checkDisjointnessConstraint(
+        { graphId, registry, backend: validationBackend },
+        node.kind,
+        node.id
+      );
+    });
+    if (!constraintResult.ok) {
+      record(node, { status: "error", error: constraintResult.error });
       continue;
     }
-    registerPendingNode(buildImportInsertParams(graphId, candidate));
+    registerPendingNode(buildImportInsertParams(graphId, node, props));
     registerPendingUniqueEntries(node.kind, node.id, props, uniqueConstraints);
     accepted.push(candidate);
   }
   if (accepted.length > 0) {
-    const insertParamsList = accepted.map(
-      (candidate) => buildImportInsertParams(graphId, candidate)
-    );
-    if (backend.insertNodesBatch === void 0) {
-      for (const params of insertParamsList) {
-        await backend.insertNode(params);
-      }
-    } else {
-      await backend.insertNodesBatch(insertParamsList);
-    }
-    await applyNodeInsertSideEffectsBatch(
-      writeContext,
-      accepted.map((candidate) => ({
-        kind: candidate.node.kind,
-        id: candidate.node.id,
-        schema: candidate.schemaEntry.registration.type.schema,
-        props: candidate.props,
-        uniqueConstraints: candidate.schemaEntry.registration.unique ?? []
-      })),
-      backend
+    await frame.session.createNodesNoReturn(
+      accepted.map(
+        (candidate) => importNodeInsertWork(
+          graphId,
+          candidate.node,
+          candidate.schemaEntry.registration,
+          candidate.props
+        )
+      )
     );
     for (const candidate of accepted) {
       record(candidate.node, { status: "created" });
@@ -969,20 +988,11 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
   for (const node of deferred) {
     record(
       node,
-      await processNode(
-        backend,
-        graphId,
-        registry,
-        node,
-        schemas,
-        options,
-        lock
-      )
+      await processNode(frame, graphId, registry, node, schemas, options)
     );
   }
 }
-function buildImportInsertParams(graphId, candidate) {
-  const { node, props } = candidate;
+function buildImportInsertParams(graphId, node, props) {
   return {
     graphId,
     kind: node.kind,
@@ -992,31 +1002,53 @@ function buildImportInsertParams(graphId, candidate) {
     ...node.validTo !== void 0 && { validTo: node.validTo }
   };
 }
-async function catchUniquenessError(fn) {
+function importNodeInsertWork(graphId, node, registration, props) {
+  return {
+    params: buildImportInsertParams(graphId, node, props),
+    claim: {
+      kind: node.kind,
+      id: node.id,
+      props,
+      constraints: registration.unique ?? []
+    },
+    sideEffects: {
+      kind: node.kind,
+      id: node.id,
+      schema: registration.type.schema,
+      props,
+      uniqueConstraints: registration.unique ?? []
+    }
+  };
+}
+async function catchDeclaredConstraintRefusal(fn) {
   try {
     return { ok: true, value: await fn() };
   } catch (error) {
-    if (error instanceof UniquenessError) {
+    if (error instanceof UniquenessError || error instanceof DisjointError || error instanceof CardinalityError) {
       return { ok: false, error: error.message };
     }
     throw error;
   }
 }
 var NODE_UPDATE_TARGET_CHANGED_CODE = "INTERCHANGE_NODE_UPDATE_TARGET_CHANGED";
-async function updateImportedNode(writeContext, backend, node, args) {
+async function updateImportedNode(session, node, args) {
   try {
-    const result = await catchUniquenessError(
-      () => applyNodeUpdate(
-        writeContext,
-        {
-          existing: args.existing,
-          schema: args.schema,
-          validatedProps: args.validatedProps,
-          uniqueConstraints: args.uniqueConstraints,
-          ...args.windowFence,
-          ...node.validTo !== void 0 && { validTo: node.validTo }
-        },
-        backend
+    const result = await catchDeclaredConstraintRefusal(
+      () => (
+        // The fence is an ARGUMENT the method requires, not a spread the call
+        // site may forget: the guard's verdict travels to the statement that
+        // honors it, and an empty fence (`{}`) is the stated decision to assert
+        // nothing rather than an omission.
+        session.reviseNode(
+          {
+            existing: args.existing,
+            schema: args.schema,
+            validatedProps: args.validatedProps,
+            uniqueConstraints: args.uniqueConstraints,
+            ...node.validTo !== void 0 && { validTo: node.validTo }
+          },
+          { validityLowerBound: args.windowFence }
+        )
       )
     );
     return result.ok ? void 0 : result.error;
@@ -1041,20 +1073,29 @@ function edgeIdentityConflict(edge, existing) {
   if (differences.length === 0) return void 0;
   return `${EDGE_IDENTITY_CONFLICT_CODE}: Edge "${edge.id}" already exists with a different immutable identity \u2014 ${differences.join("; ")}. Edge ids are unique per graph, so the incoming edge can neither update nor be created under that id. Give it a distinct id, or import it under the identity the stored row already carries.`;
 }
-async function updateImportedEdge(backend, graphId, edge, props, windowFence) {
+async function updateImportedEdge(session, edge, props, windowFence) {
   try {
-    await backend.updateEdge({
-      graphId,
-      id: edge.id,
-      kind: edge.kind,
-      fromKind: edge.from.kind,
-      fromId: edge.from.id,
-      toKind: edge.to.kind,
-      toId: edge.to.id,
-      props,
-      ...windowFence,
-      ...edge.validTo !== void 0 && { validTo: edge.validTo }
-    });
+    await session.reviseEdge(
+      {
+        id: edge.id,
+        props,
+        ...edge.validTo !== void 0 && { validTo: edge.validTo }
+      },
+      {
+        validityLowerBound: windowFence,
+        // Import re-admits no row to a counted population — it never resurrects
+        // and never clears an end — so it reads no stored `valid_to` and asserts
+        // none. `{}` is the stated decision, not an omission.
+        validityUpperBound: {},
+        edgeIdentity: {
+          kind: edge.kind,
+          fromKind: edge.from.kind,
+          fromId: edge.from.id,
+          toKind: edge.to.kind,
+          toId: edge.to.id
+        }
+      }
+    );
     return void 0;
   } catch (error) {
     if (!(error instanceof DatabaseOperationError) || error.details.reason !== "no_row_returned") {
@@ -1116,7 +1157,7 @@ function validateUpdateValidityWindow(entity, storedValidFrom) {
   );
   return verdict.ok ? { ok: true, value: verdict.value.storedLowerBoundFence } : verdict;
 }
-async function processNode(backend, graphId, registry, node, schemas, options, lock) {
+async function processNode(frame, graphId, registry, node, schemas, options) {
   const schemaEntry = schemas.get(node.kind);
   if (!schemaEntry) {
     return { status: "error", error: `Unknown node kind: ${node.kind}` };
@@ -1135,8 +1176,7 @@ async function processNode(backend, graphId, registry, node, schemas, options, l
   }
   const { registration } = schemaEntry;
   const uniqueConstraints = registration.unique ?? [];
-  const writeContext = { graphId, registry, lock };
-  const existing = await backend.getNode(graphId, node.kind, node.id);
+  const existing = await frame.target.getNode(graphId, node.kind, node.id);
   if (existing) {
     switch (options.onConflict) {
       case "skip": {
@@ -1159,18 +1199,13 @@ async function processNode(backend, graphId, registry, node, schemas, options, l
         if (!updateWindow.ok) {
           return { status: "error", error: updateWindow.error };
         }
-        const updateError = await updateImportedNode(
-          writeContext,
-          backend,
-          node,
-          {
-            existing,
-            schema: registration.type.schema,
-            validatedProps: propsResult.data,
-            uniqueConstraints,
-            windowFence: updateWindow.value
-          }
-        );
+        const updateError = await updateImportedNode(frame.session, node, {
+          existing,
+          schema: registration.type.schema,
+          validatedProps: propsResult.data,
+          uniqueConstraints,
+          windowFence: updateWindow.value
+        });
         if (updateError !== void 0) {
           return { status: "error", error: updateError };
         }
@@ -1178,45 +1213,34 @@ async function processNode(backend, graphId, registry, node, schemas, options, l
       }
     }
   }
-  const uniquenessResult = await catchUniquenessError(
-    () => checkUniquenessConstraints(
-      { graphId, registry, backend },
+  const constraintResult = await catchDeclaredConstraintRefusal(async () => {
+    await checkUniquenessConstraints(
+      { graphId, registry, backend: frame.target },
       node.kind,
       node.id,
       propsResult.data,
       uniqueConstraints
-    )
-  );
-  if (!uniquenessResult.ok) {
-    return { status: "error", error: uniquenessResult.error };
-  }
-  await backend.insertNode({
-    graphId,
-    kind: node.kind,
-    id: node.id,
-    props: propsResult.data,
-    ...node.validFrom !== void 0 && { validFrom: node.validFrom },
-    ...node.validTo !== void 0 && { validTo: node.validTo }
+    );
+    await checkDisjointnessConstraint(
+      { graphId, registry, backend: frame.target },
+      node.kind,
+      node.id
+    );
   });
-  await applyNodeInsertSideEffects(
-    writeContext,
-    {
-      kind: node.kind,
-      id: node.id,
-      schema: registration.type.schema,
-      props: propsResult.data,
-      uniqueConstraints
-    },
-    backend
+  if (!constraintResult.ok) {
+    return { status: "error", error: constraintResult.error };
+  }
+  await frame.session.createNode(
+    importNodeInsertWork(graphId, node, registration, propsResult.data)
   );
   return { status: "created" };
 }
-async function processEdges(backend, graphId, registry, edges, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
+async function processEdges(frame, graphId, registry, edges, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
   const batchSize = options.batchSize;
   for (let index = 0; index < edges.length; index += batchSize) {
     const batch = edges.slice(index, index + batchSize);
     await processEdgeSlice(
-      backend,
+      frame,
       graphId,
       registry,
       batch,
@@ -1254,10 +1278,29 @@ function recordEdgeOutcome(edge, outcome, result, errors) {
     }
   }
 }
-async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
+function edgeInsertParamsOf(graphId, candidate) {
+  const { edge, props } = candidate;
+  return {
+    graphId,
+    id: edge.id,
+    kind: edge.kind,
+    fromKind: edge.from.kind,
+    fromId: edge.from.id,
+    toKind: edge.to.kind,
+    toId: edge.to.id,
+    props,
+    ...edge.validFrom !== void 0 && { validFrom: edge.validFrom },
+    ...edge.validTo !== void 0 && { validTo: edge.validTo }
+  };
+}
+async function processEdgeSlice(frame, graphId, registry, batch, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
   const record = (edge, outcome) => {
     recordEdgeOutcome(edge, outcome, result, errors);
   };
+  const {
+    backend: cardinalityValidationBackend,
+    registerPendingEdgeForCardinality
+  } = createEdgeBatchValidationBackend(frame.target);
   const candidates = [];
   const deferred = [];
   const seenIds = /* @__PURE__ */ new Set();
@@ -1318,7 +1361,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
   }
   const liveEndpointKeys = /* @__PURE__ */ new Set();
   const checkedEndpointKeys = /* @__PURE__ */ new Set();
-  if (options.validateReferences && backend.getNodes !== void 0) {
+  if (options.validateReferences && frame.target.getNodes !== void 0) {
     const idsByKind = /* @__PURE__ */ new Map();
     for (const { edge } of candidates) {
       for (const endpoint of [edge.from, edge.to]) {
@@ -1331,7 +1374,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
       }
     }
     for (const [kind, ids] of idsByKind) {
-      const rows = await backend.getNodes(graphId, kind, [...ids]);
+      const rows = await frame.target.getNodes(graphId, kind, [...ids]);
       for (const row of rows) {
         if (isLiveNodeRow(row)) {
           liveEndpointKeys.add(makeNodeKey(kind, row.id));
@@ -1343,12 +1386,12 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
     const key = makeNodeKey(endpoint.kind, endpoint.id);
     if (importedNodeIds.has(key)) return true;
     if (checkedEndpointKeys.has(key)) return liveEndpointKeys.has(key);
-    const row = await backend.getNode(graphId, endpoint.kind, endpoint.id);
+    const row = await frame.target.getNode(graphId, endpoint.kind, endpoint.id);
     return row !== void 0 && isLiveNodeRow(row);
   };
   const existingById = /* @__PURE__ */ new Map();
-  if (candidates.length > 0 && backend.getEdges !== void 0) {
-    const rows = await backend.getEdges(
+  if (candidates.length > 0 && frame.target.getEdges !== void 0) {
+    const rows = await frame.target.getEdges(
       graphId,
       candidates.map((candidate) => candidate.edge.id)
     );
@@ -1378,7 +1421,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
         continue;
       }
     }
-    const existing = existingById.has(edge.id) ? existingById.get(edge.id) : await backend.getEdge(graphId, edge.id);
+    const existing = existingById.has(edge.id) ? existingById.get(edge.id) : await frame.target.getEdge(graphId, edge.id);
     if (existing) {
       const identityConflict = edgeIdentityConflict(edge, existing);
       if (identityConflict !== void 0) {
@@ -1414,8 +1457,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
             break;
           }
           const updateError = await updateImportedEdge(
-            backend,
-            graphId,
+            frame.session,
             edge,
             props,
             updateWindow.value
@@ -1430,28 +1472,37 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
       }
       continue;
     }
+    const insertParams = edgeInsertParamsOf(graphId, candidate);
+    const cardinality = edgeSchemas.get(edge.kind)?.registration.cardinality ?? "many";
+    const cardinalityResult = await catchDeclaredConstraintRefusal(
+      () => checkCardinalityConstraint(
+        { graphId, registry, backend: cardinalityValidationBackend },
+        edge.kind,
+        cardinality,
+        edge.from.kind,
+        edge.from.id,
+        edge.to.kind,
+        edge.to.id,
+        edge.validTo
+      )
+    );
+    if (!cardinalityResult.ok) {
+      record(edge, { status: "error", error: cardinalityResult.error });
+      continue;
+    }
+    registerPendingEdgeForCardinality(insertParams, cardinality);
     accepted.push(candidate);
   }
   if (accepted.length > 0) {
-    const insertParamsList = accepted.map(({ edge, props }) => ({
-      graphId,
-      id: edge.id,
-      kind: edge.kind,
-      fromKind: edge.from.kind,
-      fromId: edge.from.id,
-      toKind: edge.to.kind,
-      toId: edge.to.id,
-      props,
-      ...edge.validFrom !== void 0 && { validFrom: edge.validFrom },
-      ...edge.validTo !== void 0 && { validTo: edge.validTo }
-    }));
-    if (backend.insertEdgesBatch === void 0) {
-      for (const params of insertParamsList) {
-        await backend.insertEdge(params);
-      }
-    } else {
-      await backend.insertEdgesBatch(insertParamsList);
-    }
+    await frame.session.createEdgesNoReturn(
+      accepted.map(
+        (candidate) => importEdgeInsertWork(
+          graphId,
+          candidate,
+          edgeSchemas.get(candidate.edge.kind)?.registration.cardinality ?? "many"
+        )
+      )
+    );
     for (const candidate of accepted) {
       record(candidate.edge, { status: "created" });
     }
@@ -1460,7 +1511,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
     record(
       edge,
       await processEdge(
-        backend,
+        frame,
         graphId,
         registry,
         edge,
@@ -1472,7 +1523,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
     );
   }
 }
-async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSchemas, options, importedNodeIds) {
+async function processEdge(frame, graphId, registry, edge, edgeSchemas, nodeSchemas, options, importedNodeIds) {
   const schemaEntry = edgeSchemas.get(edge.kind);
   if (!schemaEntry) {
     return { status: "error", error: `Unknown edge kind: ${edge.kind}` };
@@ -1500,7 +1551,7 @@ async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSc
     const fromKey = makeNodeKey(edge.from.kind, edge.from.id);
     const toKey = makeNodeKey(edge.to.kind, edge.to.id);
     if (!importedNodeIds.has(fromKey)) {
-      const fromExists = await backend.getNode(
+      const fromExists = await frame.target.getNode(
         graphId,
         edge.from.kind,
         edge.from.id
@@ -1513,7 +1564,11 @@ async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSc
       }
     }
     if (!importedNodeIds.has(toKey)) {
-      const toExists = await backend.getNode(graphId, edge.to.kind, edge.to.id);
+      const toExists = await frame.target.getNode(
+        graphId,
+        edge.to.kind,
+        edge.to.id
+      );
       if (toExists === void 0 || !isLiveNodeRow(toExists)) {
         return {
           status: "error",
@@ -1534,7 +1589,7 @@ async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSc
   if (validityError !== void 0) {
     return { status: "error", error: validityError };
   }
-  const existing = await backend.getEdge(graphId, edge.id);
+  const existing = await frame.target.getEdge(graphId, edge.id);
   if (existing) {
     const identityConflict = edgeIdentityConflict(edge, existing);
     if (identityConflict !== void 0) {
@@ -1562,8 +1617,7 @@ async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSc
           return { status: "error", error: updateWindow.error };
         }
         const updateError = await updateImportedEdge(
-          backend,
-          graphId,
+          frame.session,
           edge,
           propsResult.data,
           updateWindow.value
@@ -1575,20 +1629,36 @@ async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSc
       }
     }
   }
-  await backend.insertEdge({
-    graphId,
-    id: edge.id,
-    kind: edge.kind,
-    fromKind: edge.from.kind,
-    fromId: edge.from.id,
-    toKind: edge.to.kind,
-    toId: edge.to.id,
-    props: propsResult.data,
-    ...edge.validFrom !== void 0 && { validFrom: edge.validFrom },
-    ...edge.validTo !== void 0 && { validTo: edge.validTo }
-  });
+  const cardinality = schemaEntry.registration.cardinality ?? "many";
+  const cardinalityResult = await catchDeclaredConstraintRefusal(
+    () => checkCardinalityConstraint(
+      { graphId, registry, backend: frame.target },
+      edge.kind,
+      cardinality,
+      edge.from.kind,
+      edge.from.id,
+      edge.to.kind,
+      edge.to.id,
+      edge.validTo
+    )
+  );
+  if (!cardinalityResult.ok) {
+    return { status: "error", error: cardinalityResult.error };
+  }
+  await frame.session.createEdge(
+    importEdgeInsertWork(
+      graphId,
+      { edge, props: propsResult.data },
+      cardinality
+    )
+  );
   return { status: "created" };
 }
+function importEdgeInsertWork(graphId, candidate, cardinality) {
+  const params = edgeInsertParamsOf(graphId, candidate);
+  const claim = edgeCardinalityClaim(cardinality, params);
+  return { params, ...claim === void 0 ? {} : { claim } };
+}
 function validateProperties(properties, schema, unknownStrategy) {
   try {
     const knownKeys = new Set(Object.keys(schema.shape));
@@ -2123,6 +2193,6 @@ async function* exportEdgeChunks(backend, graphId, kind, options) {
   }
 }
 
-export { ConflictStrategySchema, ExportOptionsSchema, ExportStreamOptionsSchema, FORMAT_VERSION, GraphDataHeaderSchema, GraphDataSchema, GraphDataSourceSchema, GraphInterchangeChunkSchema, IdentityInterchangeModeSchema, ImportErrorSchema, ImportOptionsSchema, ImportResultSchema, InterchangeEdgeSchema, InterchangeIdentityAssertionSchema, InterchangeIdentitySchema, InterchangeNodeSchema, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, exportStreamBackend, importGraph, importGraphStream, serializedStreamRefusal, withImportStreamLease };
-//# sourceMappingURL=chunk-AX6JGVTZ.js.map
-//# sourceMappingURL=chunk-AX6JGVTZ.js.map
+export { ConflictStrategySchema, ExportOptionsSchema, ExportStreamOptionsSchema, FORMAT_VERSION, GraphDataHeaderSchema, GraphDataSchema, GraphDataSourceSchema, GraphInterchangeChunkSchema, IdentityInterchangeModeSchema, ImportErrorSchema, ImportOptionsSchema, ImportResultSchema, InterchangeEdgeSchema, InterchangeIdentityAssertionSchema, InterchangeIdentitySchema, InterchangeNodeSchema, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, exportStreamBackend, importGraph, importGraphStream, registerIngestionImportTarget, serializedStreamRefusal, withImportStreamLease };
+//# sourceMappingURL=chunk-2CYI5HRH.js.map
+//# sourceMappingURL=chunk-2CYI5HRH.js.map