@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/interchange/index.d.ts

@@ -1,11 +1,11 @@
-export { C as ContributionDiagnostic, a as ContributionDiagnosticState } from '../types-Cjvkj0jA.js';
+import { d as GraphDef } from '../types-HkveCCx0.js';
+export { C as ContributionDiagnostic, a as ContributionDiagnosticState, b as ContributionRepairEntry, c as ContributionRepairResult } from '../types-HkveCCx0.js';
 import { z } from 'zod';
-import { G as GraphDef } from '../define-graph-SvYXOl78.js';
-import { a as Store } from '../store-view-Bvdku0Ht.js';
-import '../temporal--x9T8K4S.js';
-import '../manager-B0KjKE93.js';
-import '../materialize-indexes-BD4V3svD.js';
-import '../searchable-CnYEancP.js';
+import { a as Store } from '../store-DawaWWjJ.js';
+import '../temporal-BtM4UALv.js';
+import '../searchable-9OQoPuRs.js';
+import '../manager-CfZAimti.js';
+import '../materialize-indexes-BMJP6Tms.js';
 
 /**
  * Graph interchange format types.
@@ -18,10 +18,17 @@ import '../searchable-CnYEancP.js';
  */
 
 /**
- * Current interchange format version.
- * Increment for breaking changes to the format.
+ * Current interchange format version — the value every export writes.
+ *
+ * Read-side compatibility policy: the format is versioned separately from what
+ * it *accepts*. A 1.0 document is a structurally valid 2.0 document — the only
+ * 2.0 addition is the optional `identity` section — so import and
+ * {@link GraphDataSchema} accept both `"1.0"` and `"2.0"` (see
+ * {@link AcceptedFormatVersionSchema}), while exports keep writing this
+ * constant. Bump this only when exports must emit a new version; add the old
+ * value to the accepted set rather than dropping read compatibility.
  */
-declare const FORMAT_VERSION: "1.0";
+declare const FORMAT_VERSION: "2.0";
 /**
  * Interchange format for a node.
  *
@@ -67,6 +74,62 @@ declare const InterchangeEdgeSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type InterchangeEdge = z.infer<typeof InterchangeEdgeSchema>;
+declare const IdentityInterchangeModeSchema: z.ZodEnum<{
+    state: "state";
+    archival: "archival";
+}>;
+type IdentityInterchangeMode = z.infer<typeof IdentityInterchangeModeSchema>;
+declare const InterchangeIdentityAssertionSchema: z.ZodObject<{
+    id: z.ZodString;
+    relation: z.ZodEnum<{
+        same: "same";
+        different: "different";
+    }>;
+    a: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    b: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    validFrom: z.ZodISODateTime;
+    validTo: z.ZodOptional<z.ZodISODateTime>;
+    endedBy: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type InterchangeIdentityAssertion = z.infer<typeof InterchangeIdentityAssertionSchema>;
+declare const InterchangeIdentitySchema: z.ZodObject<{
+    profile: z.ZodLiteral<"typegraph-identity-v1">;
+    mode: z.ZodEnum<{
+        state: "state";
+        archival: "archival";
+    }>;
+    assertions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        relation: z.ZodEnum<{
+            same: "same";
+            different: "different";
+        }>;
+        a: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        b: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        validFrom: z.ZodISODateTime;
+        validTo: z.ZodOptional<z.ZodISODateTime>;
+        endedBy: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type InterchangeIdentity = z.infer<typeof InterchangeIdentitySchema>;
 /**
  * Strategy for handling conflicts when a node/edge ID already exists.
  *
@@ -144,7 +207,10 @@ type GraphDataSource = z.infer<typeof GraphDataSourceSchema>;
  * plus arrays of nodes and edges to import.
  */
 declare const GraphDataSchema: z.ZodObject<{
-    formatVersion: z.ZodLiteral<"1.0">;
+    formatVersion: z.ZodEnum<{
+        "2.0": "2.0";
+        "1.0": "1.0";
+    }>;
     exportedAt: z.ZodISODateTime;
     source: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"typegraph-export">;
@@ -185,6 +251,34 @@ declare const GraphDataSchema: z.ZodObject<{
             updatedAt: z.ZodOptional<z.ZodISODateTime>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    identity: z.ZodOptional<z.ZodObject<{
+        profile: z.ZodLiteral<"typegraph-identity-v1">;
+        mode: z.ZodEnum<{
+            state: "state";
+            archival: "archival";
+        }>;
+        assertions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            relation: z.ZodEnum<{
+                same: "same";
+                different: "different";
+            }>;
+            a: z.ZodObject<{
+                kind: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            b: z.ZodObject<{
+                kind: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            validFrom: z.ZodISODateTime;
+            validTo: z.ZodOptional<z.ZodISODateTime>;
+            endedBy: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type GraphData = z.infer<typeof GraphDataSchema>;
 /** The metadata envelope emitted before streamed graph entities. */
@@ -197,8 +291,18 @@ declare const GraphDataHeaderSchema: z.ZodObject<{
         type: z.ZodLiteral<"external">;
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">;
-    formatVersion: z.ZodLiteral<"1.0">;
+    formatVersion: z.ZodEnum<{
+        "2.0": "2.0";
+        "1.0": "1.0";
+    }>;
     exportedAt: z.ZodISODateTime;
+    identity: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            state: "state";
+            archival: "archival";
+        }>;
+        profile: z.ZodLiteral<"typegraph-identity-v1">;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type GraphDataHeader = z.infer<typeof GraphDataHeaderSchema>;
 /**
@@ -217,8 +321,18 @@ declare const GraphInterchangeChunkSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             type: z.ZodLiteral<"external">;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "type">;
-        formatVersion: z.ZodLiteral<"1.0">;
+        formatVersion: z.ZodEnum<{
+            "2.0": "2.0";
+            "1.0": "1.0";
+        }>;
         exportedAt: z.ZodISODateTime;
+        identity: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                state: "state";
+                archival: "archival";
+            }>;
+            profile: z.ZodLiteral<"typegraph-identity-v1">;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"nodes">;
@@ -255,6 +369,29 @@ declare const GraphInterchangeChunkSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             updatedAt: z.ZodOptional<z.ZodISODateTime>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"identity">;
+    assertions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        relation: z.ZodEnum<{
+            same: "same";
+            different: "different";
+        }>;
+        a: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        b: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        validFrom: z.ZodISODateTime;
+        validTo: z.ZodOptional<z.ZodISODateTime>;
+        endedBy: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>], "type">;
 type GraphInterchangeChunk = z.infer<typeof GraphInterchangeChunkSchema>;
 /**
@@ -264,6 +401,7 @@ declare const ImportErrorSchema: z.ZodObject<{
     entityType: z.ZodEnum<{
         node: "node";
         edge: "edge";
+        identity: "identity";
     }>;
     kind: z.ZodString;
     id: z.ZodString;
@@ -287,10 +425,15 @@ declare const ImportResultSchema: z.ZodObject<{
         updated: z.ZodNumber;
         skipped: z.ZodNumber;
     }, z.core.$strip>;
+    identity: z.ZodObject<{
+        created: z.ZodNumber;
+        skipped: z.ZodNumber;
+    }, z.core.$strip>;
     errors: z.ZodArray<z.ZodObject<{
         entityType: z.ZodEnum<{
             node: "node";
             edge: "edge";
+            identity: "identity";
         }>;
         kind: z.ZodString;
         id: z.ZodString;
@@ -307,6 +450,11 @@ declare const ExportOptionsSchema: z.ZodObject<{
     includeTemporal: z.ZodDefault<z.ZodBoolean>;
     includeMeta: z.ZodDefault<z.ZodBoolean>;
     includeDeleted: z.ZodDefault<z.ZodBoolean>;
+    identityMode: z.ZodDefault<z.ZodEnum<{
+        state: "state";
+        archival: "archival";
+    }>>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
 }, z.core.$strip>;
 /** Export options with defaults applied (output type) */
 type ExportOptions = z.infer<typeof ExportOptionsSchema>;
@@ -322,6 +470,11 @@ declare const ExportStreamOptionsSchema: z.ZodObject<{
     includeTemporal: z.ZodDefault<z.ZodBoolean>;
     includeMeta: z.ZodDefault<z.ZodBoolean>;
     includeDeleted: z.ZodDefault<z.ZodBoolean>;
+    identityMode: z.ZodDefault<z.ZodEnum<{
+        state: "state";
+        archival: "archival";
+    }>>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
     batchSize: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 type ExportStreamOptions = z.infer<typeof ExportStreamOptionsSchema>;
@@ -351,6 +504,54 @@ declare function exportGraph<G extends GraphDef>(store: Store<G>, options?: Expo
  * header, then every node chunk, then every edge chunk. Consumers that write to
  * a network, file, or fresh working copy can process one chunk at a time rather
  * than materializing a graph-sized {@link GraphData} value.
+ *
+ * ## One snapshot, WHERE THE BACKEND HAS TRANSACTIONS
+ *
+ * On a backend reporting `capabilities.transactions`, the whole export —
+ * header, every node page, every edge page, every identity page — is read
+ * inside ONE `repeatable_read` / `read_only` transaction, so a slow consumer
+ * still gets one point in time rather than a mixture of the graph as it was at
+ * the first chunk and as it is at the last.
+ *
+ * A backend WITHOUT transactions (SQLite `transactionMode: "none"`, the
+ * session-less HTTP Postgres drivers) opens no such transaction: its export
+ * paginates statement by statement, and a write committed mid-stream can appear
+ * in the pages that follow. There is no way to offer the guarantee on an engine
+ * that cannot frame the reads, so it is a declared capability gap rather than
+ * something the stream pretends to. Callers needing a coherent export from such
+ * a backend must quiesce writes for its duration.
+ *
+ * ## Stopping a stream you will not finish
+ *
+ * While a transactional stream is open it holds that snapshot transaction, and
+ * on a serialized connection it holds the connection's one EXCLUSIVE stream
+ * lease with it. Every cooperative exit settles both, because each runs the
+ * generator's `finally`: `break` or `throw` out of a `for await`, and an
+ * explicit `iterator.return()`. (A non-transactional stream holds neither, so
+ * it has nothing to strand — but it still owes its consumer an answer, which
+ * the same cancellation path gives it.)
+ *
+ * A consumer that pulls `next()` and then simply DROPS the iterator has no
+ * cooperative exit — async-generator `finally` blocks do not run on garbage
+ * collection — so it must pass {@link ExportOptions.signal} and abort it.
+ * Without that, the snapshot transaction stays open for the life of the
+ * process and every later interchange stream on that connection is refused on
+ * behalf of a stream nobody is reading.
+ *
+ * ### Why there is no garbage-collection safety net (#429)
+ *
+ * A `FinalizationRegistry` on the iterable cannot close this: it is not merely
+ * unreliable here, it can never fire. The producer is interruptible in exactly
+ * one place — it is parked in {@link RendezvousChannel.push} waiting for the
+ * consumer, not in the database — so any cleanup state capable of settling an
+ * abandoned stream has to reach that channel. A registry holds its held value
+ * STRONGLY, and holding anything that reaches the channel's scope keeps the
+ * abandoned generator permanently reachable: measured on Node 24, publishing
+ * just `channel.abort` is enough to stop the stream being collected, while
+ * publishing an unrelated object is not. The net's own bookkeeping would
+ * therefore be what kept the entry from ever firing — a safety promise that
+ * reads as protection and is not there. The signal is the mechanism, and it is
+ * a contract rather than a hint.
  */
 declare function exportGraphStream<G extends GraphDef>(store: Store<G>, options?: ExportStreamOptionsInput): AsyncIterable<GraphInterchangeChunk>;
 
@@ -360,6 +561,14 @@ declare function exportGraphStream<G extends GraphDef>(store: Store<G>, options?
  * Nodes are imported first to satisfy edge reference validation.
  * The import runs within a transaction for atomicity when supported.
  *
+ * Refused with a typed {@link ConfigurationError} when the target writes through
+ * a serialized database connection another long-lived interchange operation
+ * holds — the same refusal, codes and `details.heldBy` / `details.requested` as
+ * {@link importGraphStream}. Hand-rolling a stream as `for await (const chunk of
+ * exportGraphStream(source)) await importGraph(target, ...)` on one such
+ * connection is therefore refused on the first chunk instead of nesting a write
+ * transaction inside the export's open snapshot.
+ *
  * @param store - The graph store to import into
  * @param data - Graph data in interchange format
  * @param options - Import configuration
@@ -379,14 +588,39 @@ declare function importGraph<G extends GraphDef>(store: Store<G>, data: GraphDat
 /**
  * Imports a header-first stream of bounded interchange chunks.
  *
- * Each chunk is committed through the same {@link importGraph} implementation
- * as an in-memory import, so validation and conflict semantics stay identical.
+ * Each chunk is committed through the same implementation as an in-memory
+ * {@link importGraph}, so validation and conflict semantics stay identical; the
+ * chunk calls skip only that function's own lease claim, which this loop already
+ * holds on their behalf.
  * Chunks are individually atomic on transactional backends; a consumer needing
  * all-or-nothing behavior can import into a disposable working-copy backend and
  * publish it only after this function succeeds.
  *
  * Nodes must precede edges. Once a node chunk commits, edge validation reads the
  * target store rather than retaining every imported node id in memory.
+ *
+ * Refused with a typed {@link ConfigurationError} when the target writes through
+ * a serialized database connection that another long-lived interchange stream
+ * already holds — either because this stream came from a snapshot export on that
+ * connection, or because ANY export snapshot or streaming import holds it when
+ * the first chunk arrives (which covers a stream the caller has wrapped). The
+ * error's `details.heldBy` names the holder's kind and `details.code` the
+ * condition: `INTERCHANGE_SHARED_SERIALIZED_BACKEND_SNAPSHOT` (or
+ * `INTERCHANGE_SAME_SQLITE_BACKEND_SNAPSHOT`) behind an export snapshot,
+ * `INTERCHANGE_SERIALIZED_IMPORT_IN_PROGRESS` behind another import.
+ *
+ * Once accepted, the import holds that connection's one stream lease for the
+ * whole call — every chunk AND the trailing statistics refresh, which is a
+ * write like any other — so any export snapshot or second import that tries to
+ * start while a write of this import is still to come is the side refused, and
+ * this import keeps running instead of stalling against a transaction it can
+ * never write past.
+ *
+ * Connections we cannot observe are not detected: two clients dialed at one
+ * server, or two SQLite handles on one file, are independent and are not
+ * refused. Neither is a connection whose driver we cannot positively identify as
+ * single-connection — see the residual gap documented in
+ * `backend/transaction-resource.ts`.
  */
 declare function importGraphStream<G extends GraphDef>(store: Store<G>, chunks: AsyncIterable<GraphInterchangeChunk>, rawOptions: ImportOptions): Promise<ImportResult>;
 
@@ -402,9 +636,20 @@ type TrustedImportResult = Readonly<{
  * names, but it does not validate properties, references, cardinality, or
  * conflicts. The caller must guarantee those invariants. Use
  * {@link importGraphStream} for untrusted data.
+ *
+ * Trusted of the DATA, not of the connection: this holds ONE write transaction
+ * open for the entire stream, which makes it a long-lived import holder exactly
+ * like {@link importGraphStream}, and it is guarded the same way — the source
+ * stream's own backend is checked against the target before the first chunk, and
+ * the target connection's exclusive stream lease is held for the whole import.
+ * `trustedImportGraphStream(target, exportGraphStream(source))` over one
+ * serialized connection is therefore refused with the shared typed
+ * {@link ConfigurationError} (codes and `details.heldBy` / `details.requested`
+ * as documented on `importGraphStream`) rather than reaching the driver as a
+ * nested BEGIN.
  */
 declare function trustedImportGraphStream<G extends GraphDef>(store: Store<G>, chunks: AsyncIterable<GraphInterchangeChunk> | Iterable<GraphInterchangeChunk>): Promise<TrustedImportResult>;
 /** In-memory convenience wrapper around {@link trustedImportGraphStream}. */
 declare function trustedImportGraph<G extends GraphDef>(store: Store<G>, data: GraphData): Promise<TrustedImportResult>;
 
-export { type ConflictStrategy, ConflictStrategySchema, type ExportOptions, type ExportOptionsInput, ExportOptionsSchema, type ExportStreamOptions, type ExportStreamOptionsInput, ExportStreamOptionsSchema, FORMAT_VERSION, type GraphData, type GraphDataHeader, GraphDataHeaderSchema, GraphDataSchema, type GraphDataSource, GraphDataSourceSchema, type GraphInterchangeChunk, GraphInterchangeChunkSchema, type ImportError, ImportErrorSchema, type ImportOptions, ImportOptionsSchema, type ImportResult, ImportResultSchema, type InterchangeEdge, InterchangeEdgeSchema, type InterchangeNode, InterchangeNodeSchema, type TrustedImportResult, type UnknownPropertyStrategy, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, importGraph, importGraphStream, trustedImportGraph, trustedImportGraphStream };
+export { type ConflictStrategy, ConflictStrategySchema, type ExportOptions, type ExportOptionsInput, ExportOptionsSchema, type ExportStreamOptions, type ExportStreamOptionsInput, ExportStreamOptionsSchema, FORMAT_VERSION, type GraphData, type GraphDataHeader, GraphDataHeaderSchema, GraphDataSchema, type GraphDataSource, GraphDataSourceSchema, type GraphInterchangeChunk, GraphInterchangeChunkSchema, type IdentityInterchangeMode, IdentityInterchangeModeSchema, type ImportError, ImportErrorSchema, type ImportOptions, ImportOptionsSchema, type ImportResult, ImportResultSchema, type InterchangeEdge, InterchangeEdgeSchema, type InterchangeIdentity, type InterchangeIdentityAssertion, InterchangeIdentityAssertionSchema, InterchangeIdentitySchema, type InterchangeNode, InterchangeNodeSchema, type TrustedImportResult, type UnknownPropertyStrategy, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, importGraph, importGraphStream, trustedImportGraph, trustedImportGraphStream };

package/dist/interchange/index.js

@@ -1,24 +1,25 @@
-export { ConflictStrategySchema, ExportOptionsSchema, ExportStreamOptionsSchema, FORMAT_VERSION, GraphDataHeaderSchema, GraphDataSchema, GraphDataSourceSchema, GraphInterchangeChunkSchema, ImportErrorSchema, ImportOptionsSchema, ImportResultSchema, InterchangeEdgeSchema, InterchangeNodeSchema, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, importGraph, importGraphStream } from '../chunk-VITTKBWF.js';
-import '../chunk-SBPC5IP3.js';
-import { storeBackend } from '../chunk-FSXTPBRN.js';
-import '../chunk-35S6P5ZU.js';
-import '../chunk-MIJKEVV7.js';
-import '../chunk-FMMIX6N4.js';
-import '../chunk-2L54C2C2.js';
-import '../chunk-DK2S42XB.js';
-import '../chunk-UR7W5YQK.js';
-import '../chunk-B75XRV3O.js';
-import '../chunk-S4KQ5LV4.js';
-import '../chunk-KCO5EFJU.js';
+import { exportStreamBackend, serializedStreamRefusal, withImportStreamLease } from '../chunk-OH5E5KIO.js';
+export { ConflictStrategySchema, ExportOptionsSchema, ExportStreamOptionsSchema, FORMAT_VERSION, GraphDataHeaderSchema, GraphDataSchema, GraphDataSourceSchema, GraphInterchangeChunkSchema, IdentityInterchangeModeSchema, ImportErrorSchema, ImportOptionsSchema, ImportResultSchema, InterchangeEdgeSchema, InterchangeIdentityAssertionSchema, InterchangeIdentitySchema, InterchangeNodeSchema, UnknownPropertyStrategySchema, exportGraph, exportGraphStream, importGraph, importGraphStream } from '../chunk-OH5E5KIO.js';
+import '../chunk-QWX5YA3K.js';
+import { storeBackend } from '../chunk-WEVQJ5LH.js';
+import '../chunk-JIVMTW7W.js';
+import '../chunk-NQ6BRJBE.js';
+import '../chunk-JBQQ7THH.js';
+import '../chunk-JZUR7ZWE.js';
+import '../chunk-MSY7FSX4.js';
+import { snapshotExportContention } from '../chunk-AKLS3BYZ.js';
+import '../chunk-775A4ZMN.js';
+import '../chunk-WDGA7IYB.js';
+import { isInvertedValidityWindow, isCanonicalIsoDate } from '../chunk-DLNROMQ7.js';
 import '../chunk-2EBMPJBO.js';
-import '../chunk-K3BUWSFR.js';
-import '../chunk-6DCB664D.js';
-import '../chunk-SNXVDZAJ.js';
-import '../chunk-QMQLUA66.js';
+import '../chunk-YDFDBE6D.js';
+import '../chunk-PQBQG7IM.js';
+import '../chunk-W6OG3HDG.js';
 import { getSearchableFields, resolveGraphVectorSlots } from '../chunk-PC2UBAUB.js';
-import '../chunk-TVLKA4AY.js';
-import { TrustedImportError } from '../chunk-4MB3AQAQ.js';
-import '../chunk-G6Q5UM7U.js';
+import '../chunk-K5ELX2GT.js';
+import { TrustedImportError } from '../chunk-J3WZ3FA2.js';
+import '../chunk-FWJKWH6U.js';
+import '../chunk-DYATYRY4.js';
 
 // src/interchange/trusted-import.ts
 function rejectUnsupportedStoreFeatures(store) {
@@ -36,6 +37,13 @@ function rejectUnsupportedStoreFeatures(store) {
       { graphId: store.graphId }
     );
   }
+  if (store.graph.identity !== void 0) {
+    throw new TrustedImportError(
+      "Trusted import does not maintain Operational Identity assertions or closure.",
+      "identity_unsupported",
+      { graphId: store.graphId }
+    );
+  }
   const uniqueKinds = Object.values(store.graph.nodes).filter((registration) => (registration.unique?.length ?? 0) > 0).map((registration) => registration.type.kind);
   if (uniqueKinds.length > 0) {
     throw new TrustedImportError(
@@ -69,6 +77,32 @@ function rejectUnsupportedStoreFeatures(store) {
 function invalidStream(message) {
   return new TrustedImportError(message, "invalid_stream");
 }
+function nonCanonicalWindowOf(entity) {
+  const { validFrom, validTo } = entity;
+  if (typeof validFrom === "string" && !isCanonicalIsoDate(validFrom)) {
+    return { field: "validFrom", value: validFrom };
+  }
+  if (typeof validTo === "string" && !isCanonicalIsoDate(validTo)) {
+    return { field: "validTo", value: validTo };
+  }
+  return void 0;
+}
+function findNonCanonicalWindow(entities) {
+  for (const entity of entities) {
+    const nonCanonical = nonCanonicalWindowOf(entity);
+    if (nonCanonical !== void 0) return { entity, ...nonCanonical };
+  }
+  return void 0;
+}
+function nonCanonicalWindowMessage(subject, field, value) {
+  return `Non-canonical ${field} in trusted import: ${subject} states "${value}". Expected canonical fixed-width UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ), which is what makes a stored timestamp sort chronologically against an asOf coordinate. Convert with new Date(value).toISOString().`;
+}
+function hasInvertedWindow(entity) {
+  return isInvertedValidityWindow(
+    entity.validFrom ?? void 0,
+    entity.validTo
+  );
+}
 function nodeParams(graphId, node) {
   return {
     graphId,
@@ -116,6 +150,11 @@ async function consumeTrustedChunks(store, session, chunks) {
             "Trusted graph interchange stream emitted more than one header."
           );
         }
+        if (chunk.header.identity !== void 0) {
+          throw invalidStream(
+            "Trusted graph interchange import does not support identity data. Use importGraphStream() for an identity export."
+          );
+        }
         receivedHeader = true;
         break;
       }
@@ -138,6 +177,25 @@ async function consumeTrustedChunks(store, session, chunks) {
             `Unknown node kind in trusted import: ${unknownKind}`
           );
         }
+        const nonCanonicalNode = findNonCanonicalWindow(chunk.nodes);
+        if (nonCanonicalNode !== void 0) {
+          const { entity, field, value } = nonCanonicalNode;
+          throw invalidStream(
+            nonCanonicalWindowMessage(
+              `${entity.kind} "${entity.id}"`,
+              field,
+              value
+            )
+          );
+        }
+        const invertedNode = chunk.nodes.find(
+          (node) => hasInvertedWindow(node)
+        );
+        if (invertedNode !== void 0) {
+          throw invalidStream(
+            `Inverted validity window in trusted import: ${invertedNode.kind} "${invertedNode.id}" ends at "${String(invertedNode.validTo)}", before its validFrom "${String(invertedNode.validFrom)}".`
+          );
+        }
         await session.insertNodes(
           chunk.nodes.map((node) => nodeParams(store.graphId, node))
         );
@@ -159,12 +217,36 @@ async function consumeTrustedChunks(store, session, chunks) {
             `Unknown edge or endpoint kind in trusted import: ${invalidEdge.kind}`
           );
         }
+        const nonCanonicalEdge = findNonCanonicalWindow(chunk.edges);
+        if (nonCanonicalEdge !== void 0) {
+          const { entity, field, value } = nonCanonicalEdge;
+          throw invalidStream(
+            nonCanonicalWindowMessage(
+              `${entity.kind} edge "${entity.id}"`,
+              field,
+              value
+            )
+          );
+        }
+        const invertedEdge = chunk.edges.find(
+          (edge) => hasInvertedWindow(edge)
+        );
+        if (invertedEdge !== void 0) {
+          throw invalidStream(
+            `Inverted validity window in trusted import: ${invertedEdge.kind} edge "${invertedEdge.id}" ends at "${String(invertedEdge.validTo)}", before its validFrom "${String(invertedEdge.validFrom)}".`
+          );
+        }
         await session.insertEdges(
           chunk.edges.map((edge) => edgeParams(store.graphId, edge))
         );
         edgeCount += chunk.edges.length;
         break;
       }
+      case "identity": {
+        throw invalidStream(
+          "Trusted graph interchange import does not support identity assertions. Use importGraphStream() for an export that carries identity truth."
+        );
+      }
     }
   }
   if (!receivedHeader) {
@@ -185,6 +267,16 @@ async function trustedImportGraphStream(store, chunks) {
       { dialect: backend.dialect }
     );
   }
+  const sourceBackend = Symbol.asyncIterator in chunks ? exportStreamBackend(chunks) : void 0;
+  const contention = sourceBackend === void 0 ? void 0 : snapshotExportContention(sourceBackend, backend);
+  if (contention !== void 0) {
+    throw serializedStreamRefusal({
+      graphId: store.graphId,
+      requested: "import-stream",
+      heldBy: "export-snapshot",
+      detector: contention
+    });
+  }
   const schemaVersion = store.introspect().schemaVersion;
   const options = schemaVersion === void 0 ? void 0 : {
     schemaWrite: {
@@ -192,16 +284,28 @@ async function trustedImportGraphStream(store, chunks) {
       expectedVersion: schemaVersion
     }
   };
-  return trustedImport(
-    (session) => consumeTrustedChunks(store, session, chunks),
-    options
+  return withImportStreamLease(
+    store,
+    () => trustedImport(
+      (session) => consumeTrustedChunks(store, session, chunks),
+      options
+    )
   );
 }
 function* graphDataChunks(data) {
-  const { nodes, edges, ...header } = data;
-  yield { type: "header", header };
+  const { nodes, edges, identity, ...header } = data;
+  yield {
+    type: "header",
+    header: identity === void 0 ? header : {
+      ...header,
+      identity: { profile: identity.profile, mode: identity.mode }
+    }
+  };
   yield { type: "nodes", nodes };
   yield { type: "edges", edges };
+  if (identity !== void 0) {
+    yield { type: "identity", assertions: identity.assertions };
+  }
 }
 function trustedImportGraph(store, data) {
   return trustedImportGraphStream(store, graphDataChunks(data));