@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/{chunk-OTUPEF2W.cjs → chunk-CS6JTQQ2.cjs}

@@ -1,21 +1,22 @@
 'use strict';
 
-var chunkJB6T4GLL_cjs = require('./chunk-JB6T4GLL.cjs');
-var chunk3KOY4FH3_cjs = require('./chunk-3KOY4FH3.cjs');
-var chunkJFRT7S3B_cjs = require('./chunk-JFRT7S3B.cjs');
-var chunkEZEEWCFJ_cjs = require('./chunk-EZEEWCFJ.cjs');
-var chunkSIT26LAZ_cjs = require('./chunk-SIT26LAZ.cjs');
-var chunk5PRKMB24_cjs = require('./chunk-5PRKMB24.cjs');
-var chunkBFUOME67_cjs = require('./chunk-BFUOME67.cjs');
-var chunkFQPEMEWX_cjs = require('./chunk-FQPEMEWX.cjs');
-var chunkTQHGE7UC_cjs = require('./chunk-TQHGE7UC.cjs');
-var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
+var chunkC76WFIVZ_cjs = require('./chunk-C76WFIVZ.cjs');
+var chunkTUVD4DFR_cjs = require('./chunk-TUVD4DFR.cjs');
+var chunk7PRMDZIA_cjs = require('./chunk-7PRMDZIA.cjs');
+var chunk5OWHU7Z7_cjs = require('./chunk-5OWHU7Z7.cjs');
+var chunkRDP6ZRSM_cjs = require('./chunk-RDP6ZRSM.cjs');
+var chunkZBFZGLZE_cjs = require('./chunk-ZBFZGLZE.cjs');
+var chunkGHZPZNFC_cjs = require('./chunk-GHZPZNFC.cjs');
+var chunkG2TLHH6T_cjs = require('./chunk-G2TLHH6T.cjs');
+var chunkLLVOQOWE_cjs = require('./chunk-LLVOQOWE.cjs');
+var chunkM5MSP3BI_cjs = require('./chunk-M5MSP3BI.cjs');
+var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
 var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 var zod = require('zod');
 
 var FORMAT_VERSION = "2.0";
 var AcceptedFormatVersionSchema = zod.z.enum(["1.0", "2.0"]);
-var ValidityTimestampSchema = zod.z.iso.datetime().refine((value) => chunkTQHGE7UC_cjs.isCanonicalIsoDate(value), {
+var ValidityTimestampSchema = zod.z.iso.datetime().refine((value) => chunkM5MSP3BI_cjs.isCanonicalIsoDate(value), {
   message: "Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ); convert with new Date(value).toISOString()."
 });
 var InterchangeNodeSchema = zod.z.object({
@@ -240,6 +241,29 @@ var ExportStreamOptionsSchema = ExportOptionsSchema.extend({
   batchSize: zod.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 {
+    chunkTUVD4DFR_cjs.storeBackend(target);
+    return target;
+  } catch (error) {
+    throw new chunkX4GDXBOP_cjs.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) {
@@ -251,7 +275,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,
@@ -259,8 +284,8 @@ async function importGraph(store, data, rawOptions) {
   );
 }
 async function withImportStreamLease(store, run) {
-  const lease = chunkSIT26LAZ_cjs.acquireSerializedStreamLease(
-    chunk3KOY4FH3_cjs.storeBackend(store),
+  const lease = chunkZBFZGLZE_cjs.acquireSerializedStreamLease(
+    chunkTUVD4DFR_cjs.storeBackend(store),
     "import-stream"
   );
   if (!lease.acquired) {
@@ -283,25 +308,37 @@ async function importGraphData(store, data, options) {
   const errors = [];
   const graph = store.graph;
   const graphId = store.graphId;
-  const backend = chunk3KOY4FH3_cjs.storeBackend(store);
-  const runtime = chunk3KOY4FH3_cjs.storeRuntime(store);
+  const backend = chunkTUVD4DFR_cjs.storeBackend(store);
+  const runtime = chunkTUVD4DFR_cjs.storeRuntime(store);
   const registry = store.registry;
+  const owedClaimReason = chunkC76WFIVZ_cjs.graphOwesClaims(graph, registry);
+  const claimRefusal = owedClaimReason === void 0 ? void 0 : chunkRDP6ZRSM_cjs.constraintFenceRefusal({ graphId }, backend, owedClaimReason);
+  if (claimRefusal !== void 0) throw claimRefusal;
   const nodeSchemas = buildNodeSchemaMap(graph);
   const edgeSchemas = buildEdgeSchemaMap(graph);
   const importedNodeIds = /* @__PURE__ */ new Set();
-  await chunkJFRT7S3B_cjs.runInWriteTransaction(
+  await chunkC76WFIVZ_cjs.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.
+    chunkC76WFIVZ_cjs.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,
@@ -309,8 +346,7 @@ async function importGraphData(store, data, options) {
         options,
         result,
         errors,
-        importedNodeIds,
-        lock
+        importedNodeIds
       );
       await runtime.foldImportedIdentityNodes(
         target,
@@ -319,7 +355,7 @@ async function importGraphData(store, data, options) {
         ).map((node) => ({ kind: node.kind, id: node.id }))
       );
       await processEdges(
-        target,
+        frame,
         graphId,
         registry,
         data.edges,
@@ -349,11 +385,12 @@ 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 = chunk3KOY4FH3_cjs.storeBackend(store);
-  const contention = sourceBackend === void 0 ? void 0 : chunkSIT26LAZ_cjs.snapshotExportContention(sourceBackend, targetBackend);
+  const targetBackend = chunkTUVD4DFR_cjs.storeBackend(store);
+  const contention = sourceBackend === void 0 ? void 0 : chunkZBFZGLZE_cjs.snapshotExportContention(sourceBackend, targetBackend);
   if (contention !== void 0) {
     throw serializedStreamRefusal({
       graphId: store.graphId,
@@ -370,7 +407,7 @@ async function importGraphStream(store, chunks, rawOptions) {
   try {
     for await (const chunk of chunks) {
       if (releaseImportLease === void 0) {
-        const lease = chunkSIT26LAZ_cjs.acquireSerializedStreamLease(
+        const lease = chunkZBFZGLZE_cjs.acquireSerializedStreamLease(
           targetBackend,
           "import-stream"
         );
@@ -500,7 +537,7 @@ function serializedStreamRefusal(input) {
     requested,
     heldBy
   );
-  return new chunkMRDBBHIZ_cjs.ConfigurationError(
+  return new chunkX4GDXBOP_cjs.ConfigurationError(
     message,
     { code, graphId, requested, heldBy },
     { suggestion }
@@ -535,7 +572,7 @@ function throwIfStreamChunkFailed(result, options) {
 }
 function assertIdentityImportSupported(store, hasIdentitySection) {
   if (hasIdentitySection && store.graph.identity === void 0) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       "Cannot import identity assertions into an identity-disabled graph.",
       { code: "IDENTITY_IMPORT_REQUIRES_PROFILE", graphId: store.graphId }
     );
@@ -545,7 +582,7 @@ function validateIdentitySection(identity) {
   if (identity === void 0) return;
   const parsed = InterchangeIdentitySchema.safeParse(identity);
   if (parsed.success) return;
-  throw new chunkMRDBBHIZ_cjs.ValidationError(
+  throw new chunkX4GDXBOP_cjs.ValidationError(
     `Invalid identity interchange section: ${parsed.error.message}`,
     {
       issues: parsed.error.issues.map((issue) => ({
@@ -571,19 +608,19 @@ function identityImportError(assertion, graphId, message) {
   };
 }
 function isIdConflictError(error) {
-  return error instanceof chunkMRDBBHIZ_cjs.ConfigurationError && error.details["code"] === IDENTITY_IMPORT_ID_CONFLICT_CODE;
+  return error instanceof chunkX4GDXBOP_cjs.ConfigurationError && error.details["code"] === IDENTITY_IMPORT_ID_CONFLICT_CODE;
 }
 function touchesRef(assertion, ref) {
   return assertion.a.kind === ref.kind && assertion.a.id === ref.id || assertion.b.kind === ref.kind && assertion.b.id === ref.id;
 }
 function asIdentityImportError(assertions, graphId, error) {
   const tagged = taggedAssertion(assertions, error);
-  if (error instanceof chunkMRDBBHIZ_cjs.NodeNotFoundError) {
+  if (error instanceof chunkX4GDXBOP_cjs.NodeNotFoundError) {
     const ref = error.details;
     const assertion = tagged ?? assertions.find((candidate) => touchesRef(candidate, ref));
     return identityImportError(assertion, graphId, error.message);
   }
-  if (error instanceof chunkMRDBBHIZ_cjs.IdentityContradictionError) {
+  if (error instanceof chunkX4GDXBOP_cjs.IdentityContradictionError) {
     const { a, b } = error.details;
     const assertion = tagged ?? assertions.find(
       (candidate) => touchesRef(candidate, a) && touchesRef(candidate, b)
@@ -609,12 +646,12 @@ function asIdentityImportError(assertions, graphId, error) {
 }
 function taggedAssertion(assertions, error) {
   if (typeof error !== "object" || error === null) return void 0;
-  const id = error[chunkJFRT7S3B_cjs.IDENTITY_IMPORT_FAILED_ASSERTION];
+  const id = error[chunk5OWHU7Z7_cjs.IDENTITY_IMPORT_FAILED_ASSERTION];
   if (typeof id !== "string") return void 0;
   return assertions.find((candidate) => candidate.id === id);
 }
 function isIdentityAssertionValidationError(error) {
-  return error instanceof chunkMRDBBHIZ_cjs.ValidationError && error.details.issues.length > 0 && error.details.issues.every(
+  return error instanceof chunkX4GDXBOP_cjs.ValidationError && error.details.issues.length > 0 && error.details.issues.every(
     (issue) => issue.path === "identity.assertions" && issue.assertionId !== void 0
   );
 }
@@ -640,7 +677,7 @@ function identityImportProgress(error) {
   if (typeof error !== "object" || error === null) {
     return { created: 0, skipped: 0 };
   }
-  const progress = error[chunkJFRT7S3B_cjs.IDENTITY_IMPORT_PROGRESS];
+  const progress = error[chunk5OWHU7Z7_cjs.IDENTITY_IMPORT_PROGRESS];
   if (typeof progress !== "object" || progress === null || !("created" in progress) || typeof progress.created !== "number" || !("skipped" in progress) || typeof progress.skipped !== "number") {
     return { created: 0, skipped: 0 };
   }
@@ -649,7 +686,7 @@ function identityImportProgress(error) {
 function validateStreamHeader(header) {
   const parsed = GraphDataHeaderSchema.safeParse(header);
   if (parsed.success) return;
-  throw new chunkMRDBBHIZ_cjs.ValidationError(
+  throw new chunkX4GDXBOP_cjs.ValidationError(
     `Invalid graph interchange stream header: ${parsed.error.message}`,
     {
       issues: parsed.error.issues.map((issue) => ({
@@ -709,7 +746,7 @@ async function refreshStatisticsAfterImport(store, options, result, surface) {
 }
 function buildNodeSchemaMap(graph) {
   const map = /* @__PURE__ */ new Map();
-  for (const kindName of chunkBFUOME67_cjs.getNodeKinds(graph)) {
+  for (const kindName of chunkG2TLHH6T_cjs.getNodeKinds(graph)) {
     const registration = graph.nodes[kindName];
     map.set(kindName, {
       registration,
@@ -720,7 +757,7 @@ function buildNodeSchemaMap(graph) {
 }
 function buildEdgeSchemaMap(graph) {
   const map = /* @__PURE__ */ new Map();
-  for (const kindName of chunkBFUOME67_cjs.getEdgeKinds(graph)) {
+  for (const kindName of chunkG2TLHH6T_cjs.getEdgeKinds(graph)) {
     const registration = graph.edges[kindName];
     map.set(kindName, {
       registration,
@@ -729,12 +766,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,
@@ -742,8 +779,7 @@ async function processNodes(backend, graphId, registry, nodes, schemas, options,
       options,
       result,
       errors,
-      importedNodeIds,
-      lock
+      importedNodeIds
     );
   }
 }
@@ -777,7 +813,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);
   };
@@ -836,20 +872,21 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
     });
   }
   const {
-    backend: validationBackend,
+    reads,
+    reader: validationBackend,
     registerPendingNode,
     registerPendingUniqueEntries,
     registerAppliedNodeUpdate,
     seedNodeRow,
     seedUniqueRow
-  } = chunkJB6T4GLL_cjs.createNodeBatchValidationBackend(graphId, registry, backend);
-  await chunkJB6T4GLL_cjs.primeBatchValidationCaches(
+  } = chunkC76WFIVZ_cjs.createNodeBatchValidationSeams(graphId, registry, frame.target);
+  await chunkC76WFIVZ_cjs.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;
@@ -864,7 +901,7 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
         case "skip": {
           record(node, {
             status: "skipped",
-            liveTarget: chunk5PRKMB24_cjs.isLiveNodeRow(existing)
+            liveTarget: chunkGHZPZNFC_cjs.isLiveNodeRow(existing)
           });
           break;
         }
@@ -876,7 +913,7 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
           break;
         }
         case "update": {
-          if (!chunk5PRKMB24_cjs.isLiveNodeRow(existing)) {
+          if (!chunkGHZPZNFC_cjs.isLiveNodeRow(existing)) {
             record(node, { status: "skipped", liveTarget: false });
             break;
           }
@@ -888,30 +925,18 @@ 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,
               node.id,
-              chunk5PRKMB24_cjs.rowPropsToObject(existing.props),
+              chunkGHZPZNFC_cjs.rowPropsToObject(existing.props),
               props,
               uniqueConstraints
             );
@@ -925,44 +950,38 @@ async function processNodeSlice(backend, graphId, registry, batch, schemas, opti
       }
       continue;
     }
-    const uniquenessResult = await catchUniquenessError(
-      () => chunk3KOY4FH3_cjs.checkUniquenessConstraints(
+    const constraintResult = await catchDeclaredConstraintRefusal(async () => {
+      await chunkTUVD4DFR_cjs.checkUniquenessConstraints(
         { graphId, registry, backend: validationBackend },
         node.kind,
         node.id,
         props,
         uniqueConstraints
-      )
-    );
-    if (!uniquenessResult.ok) {
-      record(node, { status: "error", error: uniquenessResult.error });
+      );
+      await chunkC76WFIVZ_cjs.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 chunk3KOY4FH3_cjs.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" });
@@ -971,20 +990,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,
@@ -994,36 +1004,58 @@ 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 chunkMRDBBHIZ_cjs.UniquenessError) {
+    if (error instanceof chunkX4GDXBOP_cjs.UniquenessError || error instanceof chunkX4GDXBOP_cjs.DisjointError || error instanceof chunkX4GDXBOP_cjs.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(
-      () => chunk3KOY4FH3_cjs.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;
   } catch (error) {
-    if (!(error instanceof chunkMRDBBHIZ_cjs.DatabaseOperationError) || error.details.reason !== "no_row_returned") {
+    if (!(error instanceof chunkX4GDXBOP_cjs.DatabaseOperationError) || error.details.reason !== "no_row_returned") {
       throw error;
     }
     return `${NODE_UPDATE_TARGET_CHANGED_CODE}: Node "${node.kind}:${node.id}" was not updated: no live node matching the id and the validity bound this import checked remained when the write ran, so the row changed or was removed after it was checked. Re-export the source and retry.`;
@@ -1043,23 +1075,32 @@ 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 chunkMRDBBHIZ_cjs.DatabaseOperationError) || error.details.reason !== "no_row_returned") {
+    if (!(error instanceof chunkX4GDXBOP_cjs.DatabaseOperationError) || error.details.reason !== "no_row_returned") {
       throw error;
     }
     return `${EDGE_IDENTITY_CONFLICT_CODE}: Edge "${edge.id}" of kind "${edge.kind}" from "${edge.from.kind}:${edge.from.id}" to "${edge.to.kind}:${edge.to.id}" was not updated: no live edge matching the identity and the validity bound this import checked remained when the write ran, so the row changed or was removed after it was checked. Re-export the source and retry.`;
@@ -1069,9 +1110,9 @@ function windowResultOf(assert) {
   try {
     return { ok: true, value: assert() };
   } catch (error) {
-    if (error instanceof chunkMRDBBHIZ_cjs.ValidationError) {
+    if (error instanceof chunkX4GDXBOP_cjs.ValidationError) {
       const coded = error.details.issues.find(
-        (issue) => issue.code === chunkMRDBBHIZ_cjs.INVERTED_VALIDITY_WINDOW_CODE || issue.code === chunkMRDBBHIZ_cjs.IMMUTABLE_VALIDITY_LOWER_BOUND_CODE
+        (issue) => issue.code === chunkX4GDXBOP_cjs.INVERTED_VALIDITY_WINDOW_CODE || issue.code === chunkX4GDXBOP_cjs.IMMUTABLE_VALIDITY_LOWER_BOUND_CODE
       );
       if (coded !== void 0) {
         return { ok: false, error: `${coded.code}: ${error.message}` };
@@ -1089,12 +1130,12 @@ function windowErrorOf(assert) {
 }
 function validateValidityWindow(entity) {
   return windowErrorOf(() => {
-    chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(
+    chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(
       entity.validFrom ?? void 0,
       "validFrom"
     );
-    chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(entity.validTo, "validTo");
-    chunkTQHGE7UC_cjs.assertOrderedValidityWindow(
+    chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(entity.validTo, "validTo");
+    chunkM5MSP3BI_cjs.assertOrderedValidityWindow(
       `${entity.kind} "${entity.id}"`,
       entity.validFrom ?? void 0,
       entity.validTo
@@ -1103,7 +1144,7 @@ function validateValidityWindow(entity) {
 }
 function validateUpdateValidityWindow(entity, storedValidFrom) {
   const verdict = windowResultOf(
-    () => chunkTQHGE7UC_cjs.assertWritableValidityWindow(
+    () => chunkM5MSP3BI_cjs.assertWritableValidityWindow(
       `${entity.kind} "${entity.id}"`,
       entity.validFrom ?? void 0,
       {
@@ -1118,7 +1159,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}` };
@@ -1137,12 +1178,11 @@ 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": {
-        return { status: "skipped", liveTarget: chunk5PRKMB24_cjs.isLiveNodeRow(existing) };
+        return { status: "skipped", liveTarget: chunkGHZPZNFC_cjs.isLiveNodeRow(existing) };
       }
       case "error": {
         return {
@@ -1151,7 +1191,7 @@ async function processNode(backend, graphId, registry, node, schemas, options, l
         };
       }
       case "update": {
-        if (!chunk5PRKMB24_cjs.isLiveNodeRow(existing)) {
+        if (!chunkGHZPZNFC_cjs.isLiveNodeRow(existing)) {
           return { status: "skipped", liveTarget: false };
         }
         const updateWindow = validateUpdateValidityWindow(
@@ -1161,18 +1201,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 };
         }
@@ -1180,45 +1215,34 @@ async function processNode(backend, graphId, registry, node, schemas, options, l
       }
     }
   }
-  const uniquenessResult = await catchUniquenessError(
-    () => chunk3KOY4FH3_cjs.checkUniquenessConstraints(
-      { graphId, registry, backend },
+  const constraintResult = await catchDeclaredConstraintRefusal(async () => {
+    await chunkTUVD4DFR_cjs.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 chunkC76WFIVZ_cjs.checkDisjointnessConstraint(
+      { graphId, registry, backend: frame.target },
+      node.kind,
+      node.id
+    );
   });
-  await chunk3KOY4FH3_cjs.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,
@@ -1256,10 +1280,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
+  } = chunkC76WFIVZ_cjs.createEdgeBatchValidationBackend(frame.target);
   const candidates = [];
   const deferred = [];
   const seenIds = /* @__PURE__ */ new Set();
@@ -1286,7 +1329,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
       });
       continue;
     }
-    const endpointError = chunkFQPEMEWX_cjs.validateEdgeEndpoints(
+    const endpointError = chunkLLVOQOWE_cjs.validateEdgeEndpoints(
       edge.kind,
       edge.from.kind,
       edge.to.kind,
@@ -1320,7 +1363,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]) {
@@ -1333,9 +1376,9 @@ 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 (chunk5PRKMB24_cjs.isLiveNodeRow(row)) {
+        if (chunkGHZPZNFC_cjs.isLiveNodeRow(row)) {
           liveEndpointKeys.add(makeNodeKey(kind, row.id));
         }
       }
@@ -1345,12 +1388,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);
-    return row !== void 0 && chunk5PRKMB24_cjs.isLiveNodeRow(row);
+    const row = await frame.target.getNode(graphId, endpoint.kind, endpoint.id);
+    return row !== void 0 && chunkGHZPZNFC_cjs.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)
     );
@@ -1380,7 +1423,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) {
@@ -1416,8 +1459,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
             break;
           }
           const updateError = await updateImportedEdge(
-            backend,
-            graphId,
+            frame.session,
             edge,
             props,
             updateWindow.value
@@ -1432,28 +1474,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(
+      () => chunkC76WFIVZ_cjs.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" });
     }
@@ -1462,7 +1513,7 @@ async function processEdgeSlice(backend, graphId, registry, batch, edgeSchemas,
     record(
       edge,
       await processEdge(
-        backend,
+        frame,
         graphId,
         registry,
         edge,
@@ -1474,7 +1525,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}` };
@@ -1488,7 +1539,7 @@ async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSc
   if (!nodeSchemas.has(edge.to.kind)) {
     return { status: "error", error: `Unknown to node kind: ${edge.to.kind}` };
   }
-  const endpointError = chunkFQPEMEWX_cjs.validateEdgeEndpoints(
+  const endpointError = chunkLLVOQOWE_cjs.validateEdgeEndpoints(
     edge.kind,
     edge.from.kind,
     edge.to.kind,
@@ -1502,12 +1553,12 @@ 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
       );
-      if (fromExists === void 0 || !chunk5PRKMB24_cjs.isLiveNodeRow(fromExists)) {
+      if (fromExists === void 0 || !chunkGHZPZNFC_cjs.isLiveNodeRow(fromExists)) {
         return {
           status: "error",
           error: `From node not found: ${edge.from.kind}:${edge.from.id}`
@@ -1515,8 +1566,12 @@ 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);
-      if (toExists === void 0 || !chunk5PRKMB24_cjs.isLiveNodeRow(toExists)) {
+      const toExists = await frame.target.getNode(
+        graphId,
+        edge.to.kind,
+        edge.to.id
+      );
+      if (toExists === void 0 || !chunkGHZPZNFC_cjs.isLiveNodeRow(toExists)) {
         return {
           status: "error",
           error: `To node not found: ${edge.to.kind}:${edge.to.id}`
@@ -1536,7 +1591,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) {
@@ -1564,8 +1619,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
@@ -1577,20 +1631,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(
+    () => chunkC76WFIVZ_cjs.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 = chunk7PRMDZIA_cjs.edgeCardinalityClaim(cardinality, params);
+  return { params, ...claim === void 0 ? {} : { claim } };
+}
 function validateProperties(properties, schema, unknownStrategy) {
   try {
     const knownKeys = new Set(Object.keys(schema.shape));
@@ -1653,7 +1723,7 @@ function formatZodError(error) {
   }).join("; ");
 }
 function makeNodeKey(kind, id) {
-  return chunkEZEEWCFJ_cjs.encodeTupleKey([kind, id]);
+  return chunkLLVOQOWE_cjs.encodeTupleKey([kind, id]);
 }
 
 // src/interchange/export.ts
@@ -1696,7 +1766,7 @@ async function exportGraph(store, options) {
   };
 }
 function exportGraphStream(store, options) {
-  const backend = chunk3KOY4FH3_cjs.storeBackend(store);
+  const backend = chunkTUVD4DFR_cjs.storeBackend(store);
   return markExportStreamBackend(
     exportGraphStreamFromBackend(store, backend, options),
     backend
@@ -1707,7 +1777,7 @@ async function* exportGraphStreamFromBackend(store, backend, options) {
   const exportsIdentity = store.graph.identity !== void 0;
   const explicitlyDisabledTemporalFields = options?.includeTemporal === false;
   if (exportsIdentity && explicitlyDisabledTemporalFields) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       "Identity export requires temporal endpoint fields.",
       {
         code: "IDENTITY_EXPORT_REQUIRES_TEMPORAL_FIELDS",
@@ -1741,7 +1811,7 @@ async function* exportGraphStreamFromBackend(store, backend, options) {
       idleTimer = void 0;
       unsubscribeFromSignal();
       channel.abort(
-        new chunkMRDBBHIZ_cjs.ExportStreamIdleTimeoutError(
+        new chunkX4GDXBOP_cjs.ExportStreamIdleTimeoutError(
           store.graphId,
           idleTimeoutMs,
           backend.capabilities.transactions
@@ -1834,7 +1904,7 @@ function exportStreamCancelled(phase, graphId, signal, framed) {
   const message = phase === "before-open" ? "The graph export stream was aborted through its AbortSignal before it opened: no snapshot transaction was started and no database connection claimed." : framed ? "The graph export stream was aborted through its AbortSignal: its repeatable-read snapshot has been rolled back and the connection it held released." : "The graph export stream was aborted through its AbortSignal: its remaining reads were abandoned. This backend does not support transactions, so the export held no snapshot and no connection \u2014 and the chunks already delivered were never guaranteed to agree with one another.";
   const cause = signal?.reason;
   const suggestion = phase === "before-open" ? "Start a new export; the aborted one claimed nothing." : framed ? "Start a new export; the aborted one released its snapshot transaction and the connection it held." : "Start a new export; nothing was held, but discard the chunks already delivered unless partial, mutually-inconsistent data is acceptable.";
-  return new chunkMRDBBHIZ_cjs.ExportStreamCancelledError(
+  return new chunkX4GDXBOP_cjs.ExportStreamCancelledError(
     message,
     { graphId },
     {
@@ -1844,7 +1914,7 @@ function exportStreamCancelled(phase, graphId, signal, framed) {
   );
 }
 function claimSnapshotExportLeaseOrRefuse(graphId, backend) {
-  const lease = chunkSIT26LAZ_cjs.acquireSerializedStreamLease(backend, "export-snapshot");
+  const lease = chunkZBFZGLZE_cjs.acquireSerializedStreamLease(backend, "export-snapshot");
   if (!lease.acquired) {
     throw serializedStreamRefusal({
       graphId,
@@ -1856,14 +1926,14 @@ function claimSnapshotExportLeaseOrRefuse(graphId, backend) {
 }
 async function produceExportChunks(store, backend, options, emit) {
   const graphId = store.graphId;
-  const nodeKinds = options.nodeKinds ?? chunkBFUOME67_cjs.getNodeKinds(store.graph);
-  const edgeKinds = options.edgeKinds ?? chunkBFUOME67_cjs.getEdgeKinds(store.graph);
+  const nodeKinds = options.nodeKinds ?? chunkG2TLHH6T_cjs.getNodeKinds(store.graph);
+  const edgeKinds = options.edgeKinds ?? chunkG2TLHH6T_cjs.getEdgeKinds(store.graph);
   const schemaVersion = await backend.getActiveSchema(graphId);
   await emit({
     type: "header",
     header: {
       formatVersion: FORMAT_VERSION,
-      exportedAt: chunkTQHGE7UC_cjs.nowIso(),
+      exportedAt: chunkM5MSP3BI_cjs.nowIso(),
       source: {
         type: "typegraph-export",
         graphId,
@@ -1900,7 +1970,7 @@ async function produceExportChunks(store, backend, options, emit) {
   if (store.graph.identity === void 0) return;
   let after;
   for (; ; ) {
-    const page = await chunk3KOY4FH3_cjs.storeRuntime(store).readIdentityAssertionPageAtTarget(
+    const page = await chunkTUVD4DFR_cjs.storeRuntime(store).readIdentityAssertionPageAtTarget(
       backend,
       options.identityMode,
       {
@@ -2049,7 +2119,7 @@ async function* exportNodeChunks(backend, graphId, kind, options) {
       const node = {
         kind: row.kind,
         id: row.id,
-        properties: chunk5PRKMB24_cjs.rowPropsToObject(row.props)
+        properties: chunkGHZPZNFC_cjs.rowPropsToObject(row.props)
       };
       if (options.includeTemporal) {
         const validFrom = (
@@ -2099,7 +2169,7 @@ async function* exportEdgeChunks(backend, graphId, kind, options) {
           kind: row.to_kind,
           id: row.to_id
         },
-        properties: chunk5PRKMB24_cjs.rowPropsToObject(row.props)
+        properties: chunkGHZPZNFC_cjs.rowPropsToObject(row.props)
       };
       if (options.includeTemporal) {
         const validFrom = (
@@ -2147,7 +2217,8 @@ exports.exportGraphStream = exportGraphStream;
 exports.exportStreamBackend = exportStreamBackend;
 exports.importGraph = importGraph;
 exports.importGraphStream = importGraphStream;
+exports.registerIngestionImportTarget = registerIngestionImportTarget;
 exports.serializedStreamRefusal = serializedStreamRefusal;
 exports.withImportStreamLease = withImportStreamLease;
-//# sourceMappingURL=chunk-OTUPEF2W.cjs.map
-//# sourceMappingURL=chunk-OTUPEF2W.cjs.map
+//# sourceMappingURL=chunk-CS6JTQQ2.cjs.map
+//# sourceMappingURL=chunk-CS6JTQQ2.cjs.map