@nicia-ai/typegraph 0.45.0 → 0.46.0

package/dist/{chunk-ID4WXTKL.js → chunk-7Z5OR7KO.js}

@@ -1,32 +1,32 @@
-import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-YMTXMPV6.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdateWhere, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, lockSchemaVersionForStoreWrite, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-Q6EDCUXV.js';
-import { isParameterRef, resolveParameterValueType, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, storeRuntime, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, readRecordedClock, ensureRevisionOrigin, TRANSACTION_RUNTIME, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, createGraphBackendProjection, generateId, assertCurrentRecordedSchema, baseField, objectField, arrayField, dateField, numberField, computeFulltextContent, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, advanceRevisionClock, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, projectBackendMembers, sqlValueList, getEmbeddingFields, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, currentReadInstant, compileTemporalFilter, validateEdgeEndpoints, closeRecordedHardDeletedKind, buildPredicateIndex, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-TKORQCG4.js';
-import { chunk, groupBy } from './chunk-35S6P5ZU.js';
-import { DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-MIJKEVV7.js';
-import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, createBackendOverlay, INTERNAL_TEMPORARY_WRITES } from './chunk-55ITBQJI.js';
-import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, recordedInstantWallTime, asRecordedInstant, assertValidRecordedInstant } from './chunk-2L54C2C2.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, planRemovals, stripGraphExtension, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-FQ7ZPOTZ.js';
-import { compareStrings, compareCodePoints } from './chunk-DRACN6XG.js';
-import { getTypeName } from './chunk-TKP5T34P.js';
-import { validateEdgeProps } from './chunk-DK2S42XB.js';
-import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-V34A6R5V.js';
-import { isKnownKind } from './chunk-S4KQ5LV4.js';
-import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-KCO5EFJU.js';
-import { generateIndexDDL } from './chunk-FL5UQRES.js';
-import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-QLUXRWKL.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-FLEQ2HBK.js';
+import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-NMWDXFPH.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdateWhere, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, checkCardinalityConstraint, edgeWriteNeedsConstraintFence, withAlreadyExistsTranslation, rowToNodeMeta, rowToEdgeMeta } from './chunk-QWX5YA3K.js';
+import { storeRuntime, STORE_RUNTIME, TRANSACTION_RUNTIME, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, getEmbeddingFields, computeFulltextContent } from './chunk-WEVQJ5LH.js';
+import { loadAndMergeGraphExtensionDocument, serializeSchema, buildKindRegistry, ensureIdentitySchemaStorage, loadAndVerifyGraph, identitySchemaCommitPreflight, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, commitNewSchemaVersionWithPreflight, planRemovals, stripGraphExtension, applyDeprecatedKinds, identityKindCascadeNeeded, ensureSchema, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-QLRESYPU.js';
+import { getTypeName } from './chunk-JXA2ZP2Q.js';
+import { rebuildIdentityClosureForContext, loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, runInWriteTransaction, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, withWriteTransactionSession, lockSchemaVersionForStoreWrite, refKey, detachIdentityForNode, validateEdgeProps, runHookedWriteOperation, encodeTupleKey } from './chunk-JIVMTW7W.js';
+import { isParameterRef, resolveParameterValueType, fieldRef, compareStrings, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, compareCodePoints, assertRevisionTrackableBackend, createRecordedBackend, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockRecordedGraphWrite, createGraphBackendProjection, generateId, assertCurrentRecordedSchema, baseField, objectField, arrayField, dateField, numberField, advanceRevisionClock, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, projectBackendMembers, sqlValueList, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, runInsertNoReturn, currentReadInstant, compileTemporalFilter, closeRecordedHardDeletedKind, buildPredicateIndex, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-NQ6BRJBE.js';
+import { canonicalEqual, sortedReplacer } from './chunk-JBQQ7THH.js';
+import { withRecordedRelationsPrecondition, chunk, postgresReadWriteRefusedSqlState, isMissingTableError, groupBy, postgresTemporaryTableUnavailableSqlState } from './chunk-JZUR7ZWE.js';
+import { createSqlSchema, requireSqlSchema, DEFAULT_SQL_SCHEMA, recordedReadSchemaFor, requireExternalRecordedReadSource, createRecordedReadBinding, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-MSY7FSX4.js';
+import { runOptionallyInTransaction, createTransactionReadBackend, createBackendOverlay, rowPropsToObject, INTERNAL_TEMPORARY_WRITES } from './chunk-AKLS3BYZ.js';
+import { isKnownKind } from './chunk-775A4ZMN.js';
+import { validateEdgeEndpoints } from './chunk-WDGA7IYB.js';
+import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, nowIso, recordedInstantWallTime, asRecordedInstant, validateOptionalCanonicalIsoDate, assertOrderedValidityWindow, assertWritableValidityWindow, assertValidRecordedInstant, optionalRecordedInstantParts, isCanonicalIsoDate, statedBoundMatchesStored } from './chunk-DLNROMQ7.js';
+import { generateIndexDDL } from './chunk-DCQVHAYQ.js';
+import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-CBTIUB76.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-I5MOXA4H.js';
 import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
 import { DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
-import { getDialect, assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-PVUI6KGR.js';
-import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, renderSql, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledTemporaryStatementSql, asCompiledStatementSql } from './chunk-6DCB664D.js';
-import { createSchemaIntrospector } from './chunk-D7PG5D5K.js';
-import { requireDefined, isPresent } from './chunk-QMQLUA66.js';
-import { getSearchableFields, resolveEmbeddingFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage } from './chunk-PC2UBAUB.js';
-import { IncompatibleChangeError } from './chunk-4GUBTVPV.js';
-import { validateProjectionField } from './chunk-42PYUGLS.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, CompilerInvariantError, CardinalityError, EdgeNotFoundError, DatabaseOperationError, UnsupportedBackendCapabilityError, GraphAlgorithmConvergenceError, EndpointNotFoundError, InvalidEdgeWeightError } from './chunk-4MB3AQAQ.js';
-import { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-G6Q5UM7U.js';
+import { getDialect, assertVectorMinScore, assertApproximateMetricSupported, vectorScoreExpression, vectorMinScoreCondition } from './chunk-YDFDBE6D.js';
+import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, renderSql, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql, asCompiledTemporaryStatementSql } from './chunk-PQBQG7IM.js';
+import { createSchemaIntrospector } from './chunk-AMKPPFUO.js';
+import { resolveEmbeddingFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage, getSearchableFields } from './chunk-PC2UBAUB.js';
+import { IncompatibleChangeError } from './chunk-T4XNKYXB.js';
+import { META_EDGE_DISJOINT_WITH, META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS, META_EDGE_SUB_CLASS_OF } from './chunk-JXXDZTMN.js';
+import { validateProjectionField } from './chunk-K5ELX2GT.js';
+import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, ContributionRebuildUnsupportedError, CompilerInvariantError, CardinalityError, DatabaseOperationError, EdgeNotFoundError, MigrationError, EDGE_IDENTITY_MISMATCH_CODE, UnsupportedBackendCapabilityError, EndpointNotFoundError, GraphAlgorithmConvergenceError, InvalidEdgeWeightError } from './chunk-J3WZ3FA2.js';
+import { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-FWJKWH6U.js';
+import { readOwnProperty, requireDefined, createDataKeyedBag, isInteropProbeKey, hasOwnKey, isPresent } from './chunk-DYATYRY4.js';
 
 // src/store/collection-surface.ts
 var CURRENT_ONLY_READ_NAMES = [
@@ -411,6 +411,10 @@ var CoordinatePinnedView = class {
   constructor(store, coordinate) {
     this.store = store;
     this.coordinate = coordinate;
+    Object.defineProperty(this, "identity", {
+      enumerable: false,
+      get: () => storeRuntime(this.store).identityAtCoordinate(this.coordinate)
+    });
   }
   /** The temporal mode this view reads in. */
   get mode() {
@@ -532,7 +536,7 @@ var CoordinatePinnedView = class {
     });
   }
 };
-var StoreView = class extends CoordinatePinnedView {
+var StoreViewImplementation = class extends CoordinatePinnedView {
   #nodes;
   #edges;
   #search;
@@ -591,7 +595,8 @@ var StoreView = class extends CoordinatePinnedView {
     return this.#search;
   }
 };
-var RecordedStoreView = class extends CoordinatePinnedView {
+var StoreView = StoreViewImplementation;
+var RecordedStoreViewImplementation = class extends CoordinatePinnedView {
   #nodes;
   #edges;
   constructor(store, coordinate) {
@@ -650,6 +655,48 @@ var RecordedStoreView = class extends CoordinatePinnedView {
     return this.#edges;
   }
 };
+var RecordedStoreView = RecordedStoreViewImplementation;
+
+// src/utils/path.ts
+function parseSqlitePath(path) {
+  const emptyPath = `${SQLITE_PATH_DELIMITER}${SQLITE_PATH_DELIMITER}`;
+  if (!path || path === emptyPath) return [];
+  const trimmed = path.slice(1, -1);
+  if (trimmed === "") return [];
+  return trimmed.split(SQLITE_PATH_DELIMITER);
+}
+function isSqlitePath(value) {
+  return typeof value === "string" && value.startsWith(SQLITE_PATH_DELIMITER) && value.endsWith(SQLITE_PATH_DELIMITER);
+}
+function normalizePath(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (isSqlitePath(value)) {
+    return parseSqlitePath(value);
+  }
+  if (isPostgresTextArray(value)) {
+    return parsePostgresTextArray(value);
+  }
+  return [];
+}
+var IDENTITY_PATH_TOKEN_SEPARATOR = "";
+function stripIdentityPathTokens(path) {
+  return path.map((token) => stripIdentityPathToken(token));
+}
+function stripIdentityPathToken(token) {
+  const separatorIndex = token.indexOf(IDENTITY_PATH_TOKEN_SEPARATOR);
+  if (separatorIndex === -1) return token;
+  return token.slice(separatorIndex + IDENTITY_PATH_TOKEN_SEPARATOR.length);
+}
+function isPostgresTextArray(value) {
+  return typeof value === "string" && value.startsWith(PG_ARRAY_START) && value.endsWith(PG_ARRAY_END);
+}
+function parsePostgresTextArray(value) {
+  const inner = value.slice(1, -1);
+  if (inner === "") return [];
+  return inner.split(PG_PATH_ELEMENT_SEPARATOR);
+}
 
 // src/query/compiler/emitter/plan-inspector.ts
 function collectPlanOperations(node, ops) {
@@ -865,9 +912,13 @@ function assertRecursiveEmitterClauseAlignment(logicalPlan, input) {
 }
 function emitRecursiveQuerySql(input) {
   assertRecursiveEmitterClauseAlignment(input.logicalPlan, input);
+  const cteList = sql.join(
+    [...input.precedingCtes ?? [], input.recursiveCte],
+    sql`, `
+  );
   const parts = [
     sql`WITH RECURSIVE`,
-    input.recursiveCte,
+    cteList,
     sql`SELECT ${input.projection}`,
     sql`FROM recursive_cte`,
     input.depthFilter
@@ -1023,6 +1074,118 @@ function mergeEdgeKinds(traversal) {
   ];
 }
 
+// src/query/compiler/identity-traversal.ts
+var IDENTITY_CLASS_CTE_ALIAS = "identity_peer_class";
+var PEER_CLASS_ALIAS = "identity_peer";
+var CURRENT_SEED_CLASS_ALIAS = "identity_seed_class";
+var CURRENT_MEMBER_NODE_ALIAS = "identity_peer_node";
+function historicalCoordinate(input) {
+  const { ast, temporalFilterPass } = input;
+  const recorded = optionalRecordedInstantParts(
+    ast.recordedAsOf,
+    "recordedAsOf"
+  );
+  if (recorded === void 0 && ast.temporalMode.mode === "current") {
+    return void 0;
+  }
+  return {
+    validMode: ast.temporalMode.mode,
+    validAsOf: ast.temporalMode.asOf,
+    recorded,
+    currentInstant: temporalFilterPass.currentInstant
+  };
+}
+function compileIdentityClassCte(input) {
+  const { ast, ctx, graphId, temporalFilterPass } = input;
+  const expandsIdentity = ast.traversals.some(
+    (traversal) => traversal.includeIdentityMembers === true
+  );
+  if (!expandsIdentity) return void 0;
+  const coordinate = historicalCoordinate({ ast, temporalFilterPass });
+  if (coordinate === void 0) return void 0;
+  const peerClasses = historicalIdentityPeerClassQuery({
+    schema: ctx.schema,
+    graphId,
+    coordinate,
+    sameIdAcrossKinds: ctx.identitySameIdAcrossKinds ?? "fold"
+  });
+  return sql`
+    ${sql.identifier(IDENTITY_CLASS_CTE_ALIAS)}(${IDENTITY_PEER_CLASS_COLUMNS}) AS MATERIALIZED (
+      ${peerClasses}
+    )
+  `;
+}
+function planCurrentIdentityFrontierExpansion(input) {
+  const { ctx, graphId, previousId, previousKind, temporalFilterPass } = input;
+  const seedClass = sql.raw(CURRENT_SEED_CLASS_ALIAS);
+  const peer = sql.raw(PEER_CLASS_ALIAS);
+  const memberNode = sql.raw(CURRENT_MEMBER_NODE_ALIAS);
+  return {
+    frontierJoin: sql`
+      LEFT JOIN ${ctx.schema.identityClosureTable} ${seedClass}
+        ON ${seedClass}.graph_id = ${graphId}
+       AND ${seedClass}.member_kind = ${previousKind}
+       AND ${seedClass}.member_id = ${previousId}
+      LEFT JOIN ${ctx.schema.identityClosureTable} ${peer}
+        ON ${peer}.graph_id = ${seedClass}.graph_id
+       AND ${peer}.class_kind = ${seedClass}.class_kind
+       AND ${peer}.class_id = ${seedClass}.class_id
+      LEFT JOIN ${ctx.schema.nodesTable} ${memberNode}
+        ON ${memberNode}.graph_id = ${peer}.graph_id
+       AND ${memberNode}.kind = ${peer}.member_kind
+       AND ${memberNode}.id = ${peer}.member_id
+       AND ${temporalFilterPass.forAlias(CURRENT_MEMBER_NODE_ALIAS)}
+    `,
+    memberId: sql`COALESCE(${peer}.member_id, ${previousId})`,
+    memberKind: sql`COALESCE(${peer}.member_kind, ${previousKind})`,
+    whereClauses: [
+      sql`(${peer}.member_id IS NULL OR ${memberNode}.id IS NOT NULL)`
+    ]
+  };
+}
+function planHistoricalIdentityFrontierExpansion(input) {
+  const { previousId, previousKind } = input;
+  const peer = sql.identifier(PEER_CLASS_ALIAS);
+  return {
+    frontierJoin: sql`
+      LEFT JOIN ${sql.identifier(IDENTITY_CLASS_CTE_ALIAS)} ${peer}
+        ON ${peer}.seed_kind = ${previousKind}
+       AND ${peer}.seed_id = ${previousId}
+    `,
+    memberId: sql`COALESCE(${peer}.id, ${previousId})`,
+    memberKind: sql`COALESCE(${peer}.kind, ${previousKind})`,
+    whereClauses: []
+  };
+}
+function planIdentityFrontierExpansion(input) {
+  const { ast, ctx, graphId, previousId, previousKind, temporalFilterPass } = input;
+  const coordinate = historicalCoordinate({ ast, temporalFilterPass });
+  if (coordinate !== void 0) {
+    return planHistoricalIdentityFrontierExpansion({
+      previousId,
+      previousKind
+    });
+  }
+  return planCurrentIdentityFrontierExpansion({
+    ctx,
+    graphId,
+    previousId,
+    previousKind,
+    temporalFilterPass
+  });
+}
+
+// src/query/compiler/inverse-traversal-guard.ts
+function compileInverseTraversalDuplicateGuard(directEdgeKinds, inverseEdgeKinds, compileKindFilter3) {
+  const overlappingKinds = inverseEdgeKinds.filter(
+    (kind) => directEdgeKinds.includes(kind)
+  );
+  if (overlappingKinds.length === 0) {
+    return void 0;
+  }
+  return sql`NOT (e.from_id = e.to_id AND e.from_kind = e.to_kind AND ${compileKindFilter3(overlappingKinds)})`;
+}
+
 // src/query/compiler/typed-json-extract.ts
 function compileTypedJsonExtract(input) {
   const { column, dialect, pointer, valueType } = input;
@@ -1337,24 +1500,71 @@ function buildStandardTraversalCte(input) {
     })
   ];
   const cteMaterialization = materializeCte ? sql`MATERIALIZED ` : ctx.dialect.capabilities.emitNotMaterializedHint ? sql`NOT MATERIALIZED ` : sql``;
+  const previousIdColumn = sql`cte_${sql.raw(previousAlias)}.${sql.raw(`${previousAlias}_id`)}`;
+  const previousKindColumn = sql`cte_${sql.raw(previousAlias)}.${sql.raw(`${previousAlias}_kind`)}`;
+  const identityFrontierExpansion = traversal.includeIdentityMembers === true ? planIdentityFrontierExpansion({
+    ast,
+    ctx,
+    graphId,
+    previousId: previousIdColumn,
+    previousKind: previousKindColumn,
+    temporalFilterPass
+  }) : void 0;
+  const pinFrontierAheadOfEdges = identityFrontierExpansion !== void 0 && ctx.dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
+  function compileSourceJoin(branch) {
+    const edgeId = sql`e.${sql.raw(branch.joinField)}`;
+    const edgeKind = sql`e.${sql.raw(branch.joinKindField)}`;
+    if (identityFrontierExpansion !== void 0) {
+      return sql`
+        ${identityFrontierExpansion.memberId} = ${edgeId}
+        AND ${identityFrontierExpansion.memberKind} = ${edgeKind}
+      `;
+    }
+    return sql`
+      ${previousIdColumn} = ${edgeId}
+      AND ${previousKindColumn} = ${edgeKind}
+    `;
+  }
   function compileTraversalBranch(branch) {
     const whereClauses = [
       ...baseWhereClauses,
+      // Conditions the frontier widening cannot state in a join condition —
+      // currently the member-visibility guard. Every branch of the step carries
+      // them, because every branch reads the widened frontier.
+      ...identityFrontierExpansion?.whereClauses ?? [],
       compileKindFilter(sql.raw("e.kind"), branch.edgeKinds),
-      compileKindFilter(
-        sql.raw(`e.${branch.joinKindField}`),
-        previousNodeKinds
-      ),
       compileKindFilter(sql.raw(`e.${branch.targetKindField}`), nodeKinds)
     ];
+    if (traversal.includeIdentityMembers !== true) {
+      whereClauses.push(
+        compileKindFilter(
+          sql.raw(`e.${branch.joinKindField}`),
+          previousNodeKinds
+        )
+      );
+    }
     if (branch.duplicateGuard !== void 0) {
       whereClauses.push(branch.duplicateGuard);
     }
+    const sourceJoin = compileSourceJoin(branch);
+    const frontierJoin = identityFrontierExpansion?.frontierJoin ?? sql``;
+    if (pinFrontierAheadOfEdges) {
+      return sql`
+        SELECT ${sql.join(selectColumns, sql`, `)}
+        FROM cte_${sql.raw(previousAlias)}
+        ${frontierJoin}
+        CROSS JOIN ${ctx.schema.edgesTable} e
+        JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
+          AND n.id = e.${sql.raw(branch.targetField)}
+          AND n.kind = e.${sql.raw(branch.targetKindField)}
+        WHERE ${sql.join([sourceJoin, ...whereClauses], sql` AND `)}
+      `;
+    }
     return sql`
       SELECT ${sql.join(selectColumns, sql`, `)}
       FROM cte_${sql.raw(previousAlias)}
-      JOIN ${ctx.schema.edgesTable} e ON cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_id = e.${sql.raw(branch.joinField)}
-        AND cte_${sql.raw(previousAlias)}.${sql.raw(previousAlias)}_kind = e.${sql.raw(branch.joinKindField)}
+      ${frontierJoin}
+      JOIN ${ctx.schema.edgesTable} e ON ${sourceJoin}
       JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
         AND n.id = e.${sql.raw(branch.targetField)}
         AND n.kind = e.${sql.raw(branch.targetKindField)}
@@ -1393,13 +1603,11 @@ function buildStandardTraversalCte(input) {
   const inverseTargetField = traversal.direction === "out" ? "from_id" : "to_id";
   const inverseJoinKindField = traversal.direction === "out" ? "to_kind" : "from_kind";
   const inverseTargetKindField = traversal.direction === "out" ? "from_kind" : "to_kind";
-  const overlappingKinds = inverseEdgeKinds.filter(
-    (kind) => directEdgeKinds.includes(kind)
+  const duplicateGuard = compileInverseTraversalDuplicateGuard(
+    directEdgeKinds,
+    inverseEdgeKinds,
+    (overlappingKinds) => compileKindFilter(sql.raw("e.kind"), overlappingKinds)
   );
-  const duplicateGuard = overlappingKinds.length > 0 ? sql`NOT (e.from_id = e.to_id AND ${compileKindFilter(
-    sql.raw("e.kind"),
-    overlappingKinds
-  )})` : void 0;
   const inverseBranch = compileTraversalBranch({
     duplicateGuard,
     edgeKinds: inverseEdgeKinds,
@@ -1803,6 +2011,16 @@ function buildStandardEmbeddingsCte(input) {
     const tableName = vectorStrategy.tableName(graphId, kind, fieldPath);
     const slotDescriptor = vectorSlots?.get(vectorSlotKey(kind, fieldPath));
     const branchMetric = metric ?? slotDescriptor?.metric ?? "cosine";
+    if (slotDescriptor !== void 0) {
+      assertApproximateMetricSupported({
+        approximate: vectorPredicate.approximate,
+        requestedMetric: metric,
+        declaredMetric: slotDescriptor.metric,
+        indexType: slotDescriptor.indexType,
+        nodeKind: kind,
+        fieldPath
+      });
+    }
     const engineFormEligible = vectorPredicate.approximate === true || vectorStrategy.searchIsExact === true;
     const annSlot = engineFormEligible && branchMetric === slotDescriptor?.metric ? slotDescriptor : void 0;
     if (annSlot !== void 0) {
@@ -2152,7 +2370,8 @@ function createTemporalFilterPass(ast, readInstant = "literal") {
         ...extractTemporalOptions(ast, tableAlias),
         currentTimestamp
       });
-    }
+    },
+    currentInstant: currentTimestamp
   };
 }
 
@@ -2600,6 +2819,12 @@ function throwRecordedCurrentIndexError(recordedAsOf, usage) {
 var MAX_RECURSIVE_DEPTH = 10;
 var MAX_EXPLICIT_RECURSIVE_DEPTH = 1e3;
 var NO_ALWAYS_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
+function compilePathToken(tableAlias, composite) {
+  if (!composite) {
+    return sql.raw(`${tableAlias}.id`);
+  }
+  return sql`(${sql.raw(`${tableAlias}.kind`)} || ${IDENTITY_PATH_TOKEN_SEPARATOR} || ${sql.raw(`${tableAlias}.id`)})`;
+}
 function runRecursiveQueryPassPipeline(ast, graphId, ctx) {
   let state = {
     ast,
@@ -2720,6 +2945,12 @@ function compileVariableLengthQueryWithRecursiveCteStrategy(ast, graphId, ctx) {
     requiredColumnsByAlias,
     temporalFilterPass
   );
+  const identityClassCte = compileIdentityClassCte({
+    ast,
+    ctx,
+    graphId,
+    temporalFilterPass
+  });
   const projection = compileRecursiveProjection(ast, vlTraversal, dialect);
   const minDepth = vlTraversal.variableLength.minDepth;
   const depthFilter = minDepth > 0 ? sql`WHERE depth >= ${minDepth}` : sql.raw("");
@@ -2730,6 +2961,7 @@ function compileVariableLengthQueryWithRecursiveCteStrategy(ast, graphId, ctx) {
     ...limitOffset === void 0 ? {} : { limitOffset },
     logicalPlan,
     ...orderBy === void 0 ? {} : { orderBy },
+    ...identityClassCte === void 0 ? {} : { precedingCtes: [identityClassCte] },
     projection,
     recursiveCte
   });
@@ -2752,7 +2984,7 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
   const shouldEnforceCycleCheck = vl.cyclePolicy !== "allow";
   const shouldTrackPath = shouldEnforceCycleCheck || vl.pathAlias !== void 0;
   const recursiveJoinRequiredColumns = /* @__PURE__ */ new Set(["id"]);
-  if (previousNodeKinds.length > 1) {
+  if (previousNodeKinds.length > 1 || traversal.includeIdentityMembers === true) {
     recursiveJoinRequiredColumns.add("kind");
   }
   const requiredStartColumns = requiredColumnsByAlias ? requiredColumnsByAlias.get(startAlias) ?? EMPTY_REQUIRED_COLUMNS : void 0;
@@ -2806,33 +3038,74 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
   }
   const effectiveMaxDepth = vl.maxDepth > 0 ? vl.maxDepth : MAX_RECURSIVE_DEPTH;
   const maxDepthCondition = sql`r.depth < ${effectiveMaxDepth}`;
-  const cycleCheck = shouldEnforceCycleCheck ? dialect.cycleCheck(sql.raw("n.id"), sql.raw("r.path")) : void 0;
-  const initialPath = shouldTrackPath ? dialect.initializePath(sql.raw("n0.id")) : void 0;
-  const pathExtension = shouldTrackPath ? dialect.extendPath(sql.raw("r.path"), sql.raw("n.id")) : void 0;
+  const baseToken = compilePathToken(
+    "n0",
+    traversal.includeIdentityMembers === true
+  );
+  const stepToken = compilePathToken(
+    "n",
+    traversal.includeIdentityMembers === true
+  );
+  const cycleCheck = shouldEnforceCycleCheck ? dialect.cycleCheck(stepToken, sql.raw("r.path")) : void 0;
+  const initialPath = shouldTrackPath ? dialect.initializePath(baseToken) : void 0;
+  const pathExtension = shouldTrackPath ? dialect.extendPath(sql.raw("r.path"), stepToken) : void 0;
   const baseWhereClauses = [
     sql`n0.graph_id = ${graphId}`,
     startKindFilter,
     startTemporalFilter,
     ...startPredicates
   ];
+  const previousIdColumn = sql`r.${sql.raw(nodeAlias)}_id`;
+  const previousKindColumn = sql`r.${sql.raw(nodeAlias)}_kind`;
+  const identityFrontierExpansion = traversal.includeIdentityMembers === true ? planIdentityFrontierExpansion({
+    ast,
+    ctx,
+    graphId,
+    previousId: previousIdColumn,
+    previousKind: previousKindColumn,
+    temporalFilterPass
+  }) : void 0;
   const recursiveBaseWhereClauses = [
     sql`e.graph_id = ${graphId}`,
     nodeKindFilter,
     edgeTemporalFilter,
     nodeTemporalFilter,
-    maxDepthCondition
+    maxDepthCondition,
+    // Conditions the frontier widening cannot state in a join condition —
+    // currently the member-visibility guard. Every branch of the recursive term
+    // carries them, because every branch reads the widened frontier.
+    ...identityFrontierExpansion?.whereClauses ?? []
   ];
   if (cycleCheck !== void 0) {
     recursiveBaseWhereClauses.push(cycleCheck);
   }
   recursiveBaseWhereClauses.push(...edgePredicates, ...targetNodePredicates);
+  function compileWorktableJoinClauses(branch) {
+    const edgeId = sql`e.${sql.raw(branch.joinField)}`;
+    const edgeKind = sql`e.${sql.raw(branch.joinKindField)}`;
+    if (identityFrontierExpansion !== void 0) {
+      return [
+        sql`${edgeId} = ${identityFrontierExpansion.memberId}`,
+        sql`${edgeKind} = ${identityFrontierExpansion.memberKind}`
+      ];
+    }
+    const clauses = [sql`${edgeId} = ${previousIdColumn}`];
+    if (previousNodeKinds.length > 1) {
+      clauses.push(sql`${edgeKind} = ${previousKindColumn}`);
+    }
+    return clauses;
+  }
   function compileRecursiveBranch2(branch) {
     const recursiveFilterClauses = [
       ...recursiveBaseWhereClauses,
       compileKindFilter2(branch.edgeKinds, "e.kind"),
-      compileKindFilter2(previousNodeKinds, `e.${branch.joinKindField}`),
       compileKindFilter2(nodeKinds, `e.${branch.targetKindField}`)
     ];
+    if (traversal.includeIdentityMembers !== true) {
+      recursiveFilterClauses.push(
+        compileKindFilter2(previousNodeKinds, `e.${branch.joinKindField}`)
+      );
+    }
     if (branch.duplicateGuard !== void 0) {
       recursiveFilterClauses.push(branch.duplicateGuard);
     }
@@ -2844,14 +3117,8 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
     if (pathExtension !== void 0) {
       recursiveSelectColumns.push(sql`${pathExtension} AS path`);
     }
-    const recursiveJoinClauses = [
-      sql`e.${sql.raw(branch.joinField)} = r.${sql.raw(nodeAlias)}_id`
-    ];
-    if (previousNodeKinds.length > 1) {
-      recursiveJoinClauses.push(
-        sql`e.${sql.raw(branch.joinKindField)} = r.${sql.raw(nodeAlias)}_kind`
-      );
-    }
+    const recursiveJoinClauses = compileWorktableJoinClauses(branch);
+    const frontierJoin = identityFrontierExpansion?.frontierJoin ?? sql``;
     if (forceWorktableOuterJoinOrder) {
       const recursiveWhereClauses = [
         ...recursiveJoinClauses,
@@ -2860,6 +3127,7 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
       return sql`
         SELECT ${sql.join(recursiveSelectColumns, sql`, `)}
         FROM recursive_cte r
+        ${frontierJoin}
         CROSS JOIN ${ctx.schema.edgesTable} e
         JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
           AND n.id = e.${sql.raw(branch.targetField)}
@@ -2870,6 +3138,7 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
     return sql`
       SELECT ${sql.join(recursiveSelectColumns, sql`, `)}
       FROM recursive_cte r
+      ${frontierJoin}
       JOIN ${ctx.schema.edgesTable} e ON ${sql.join(recursiveJoinClauses, sql` AND `)}
       JOIN ${ctx.schema.nodesTable} n ON n.graph_id = e.graph_id
         AND n.id = e.${sql.raw(branch.targetField)}
@@ -2893,10 +3162,11 @@ function compileRecursiveCte(ast, traversal, graphId, ctx, requiredColumnsByAlia
     const inverseTargetField = direction === "out" ? "from_id" : "to_id";
     const inverseJoinKindField = direction === "out" ? "to_kind" : "from_kind";
     const inverseTargetKindField = direction === "out" ? "from_kind" : "to_kind";
-    const overlappingKinds = inverseEdgeKinds.filter(
-      (kind) => directEdgeKinds.includes(kind)
+    const duplicateGuard = compileInverseTraversalDuplicateGuard(
+      directEdgeKinds,
+      inverseEdgeKinds,
+      (overlappingKinds) => compileKindFilter2(overlappingKinds, "e.kind")
     );
-    const duplicateGuard = overlappingKinds.length > 0 ? sql`NOT (e.from_id = e.to_id AND ${compileKindFilter2(overlappingKinds, "e.kind")})` : void 0;
     const inverseBranch = compileRecursiveBranch2({
       joinField: inverseJoinField,
       targetField: inverseTargetField,
@@ -3419,7 +3689,7 @@ function buildProjectionPlan(kinds, projectionMap, resolveFieldType, entityPrefi
   const projectedKinds = /* @__PURE__ */ new Map();
   const fullKinds = [];
   for (const kind of kinds) {
-    const selection = projectionMap?.[kind];
+    const selection = projectionMap !== void 0 && hasOwnKey(projectionMap, kind) ? projectionMap[kind] : void 0;
     if (selection === void 0) {
       fullKinds.push(kind);
       continue;
@@ -4241,6 +4511,7 @@ function compileQuery(ast, graphId, options = "sqlite") {
     schema,
     annIndexTypes,
     readInstant: options_.readInstant ?? "literal",
+    identitySameIdAcrossKinds: options_.identitySameIdAcrossKinds ?? "fold",
     compileQuery: (subAst, subGraphId) => compileQuery(
       inheritRecordedAsOf(subAst, ast.recordedAsOf),
       subGraphId,
@@ -4350,7 +4621,10 @@ function propagateOptions(options_) {
     ...options_.vectorSlots === void 0 ? {} : { vectorSlots: options_.vectorSlots },
     ...options_.fulltextLanguages === void 0 ? {} : { fulltextLanguages: options_.fulltextLanguages },
     ...options_.recordedReadBinding === void 0 ? {} : { recordedReadBinding: options_.recordedReadBinding },
-    ...options_.readInstant === void 0 ? {} : { readInstant: options_.readInstant }
+    ...options_.readInstant === void 0 ? {} : { readInstant: options_.readInstant },
+    ...options_.identitySameIdAcrossKinds === void 0 ? {} : {
+      identitySameIdAcrossKinds: options_.identitySameIdAcrossKinds
+    }
   };
 }
 function resolveCountAggregateFastPath(ast) {
@@ -4418,6 +4692,11 @@ function resolveCountAggregateFastPath(ast) {
   };
 }
 function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredColumnsByAlias, predicateIndex, temporalFilterPass) {
+  if (ast.traversals.some(
+    (traversal2) => traversal2.includeIdentityMembers === true
+  )) {
+    return void 0;
+  }
   const plan = resolveCountAggregateFastPath(ast);
   if (!plan) {
     return void 0;
@@ -4609,7 +4888,14 @@ function buildStandardStartAndTraversalCtes(input) {
     temporalFilterPass,
     traversalLimit
   } = input;
+  const identityClassCte = compileIdentityClassCte({
+    ast,
+    ctx,
+    graphId,
+    temporalFilterPass
+  });
   const ctes = [
+    ...identityClassCte === void 0 ? [] : [identityClassCte],
     buildStandardStartCte({
       ast,
       ctx,
@@ -4946,57 +5232,35 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
   });
 }
 
-// src/utils/path.ts
-function parseSqlitePath(path) {
-  const emptyPath = `${SQLITE_PATH_DELIMITER}${SQLITE_PATH_DELIMITER}`;
-  if (!path || path === emptyPath) return [];
-  const trimmed = path.slice(1, -1);
-  if (trimmed === "") return [];
-  return trimmed.split(SQLITE_PATH_DELIMITER);
-}
-function isSqlitePath(value) {
-  return typeof value === "string" && value.startsWith(SQLITE_PATH_DELIMITER) && value.endsWith(SQLITE_PATH_DELIMITER);
-}
-function normalizePath(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (isSqlitePath(value)) {
-    return parseSqlitePath(value);
-  }
-  if (isPostgresTextArray(value)) {
-    return parsePostgresTextArray(value);
-  }
-  return [];
-}
-function isPostgresTextArray(value) {
-  return typeof value === "string" && value.startsWith(PG_ARRAY_START) && value.endsWith(PG_ARRAY_END);
-}
-function parsePostgresTextArray(value) {
-  const inner = value.slice(1, -1);
-  if (inner === "") return [];
-  return inner.split(PG_PATH_ELEMENT_SEPARATOR);
-}
-
 // src/query/execution/result-mapper.ts
-function transformPathColumns(rows, state, _dialect) {
-  const pathAliases = [];
+function collectPathColumns(state) {
+  const columns = [];
   for (const traversal of state.traversals) {
-    if (traversal.variableLength?.pathAlias !== void 0) {
-      pathAliases.push(traversal.variableLength.pathAlias);
+    const pathAlias = traversal.variableLength?.pathAlias;
+    if (pathAlias !== void 0) {
+      columns.push({
+        alias: pathAlias,
+        identityExpanded: traversal.includeIdentityMembers === true
+      });
     }
   }
-  if (pathAliases.length === 0) return rows;
+  return columns;
+}
+function transformPathColumns(rows, state, _dialect) {
+  const pathColumns = collectPathColumns(state);
+  if (pathColumns.length === 0) return rows;
   const result = [];
   let changed = false;
   for (const row of rows) {
     let transformed;
-    for (const alias of pathAliases) {
+    for (const { alias, identityExpanded } of pathColumns) {
       const value = row[alias];
-      if (value !== void 0 && !Array.isArray(value)) {
-        transformed ??= { ...row };
-        transformed[alias] = normalizePath(value);
-      }
+      if (value === void 0) continue;
+      const normalized = normalizePath(value);
+      const path = identityExpanded ? stripIdentityPathTokens(normalized) : normalized;
+      if (path === value) continue;
+      transformed ??= { ...row };
+      transformed[alias] = path;
     }
     if (transformed === void 0) {
       result.push(row);
@@ -5008,16 +5272,24 @@ function transformPathColumns(rows, state, _dialect) {
   return changed ? result : rows;
 }
 var RESERVED_NODE_KEYS = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
-var RESERVED_EDGE_KEYS = /* @__PURE__ */ new Set(["id", "kind", "fromId", "toId", "meta"]);
+var RESERVED_EDGE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "fromId",
+  "toId",
+  "meta"
+]);
 function nullToUndefined2(value) {
   return value === null ? void 0 : value;
 }
-function assignPropsExcludingReserved(target, props, reservedKeys) {
+function propsExcludingReserved(props, reservedKeys) {
+  const kept = createDataKeyedBag();
   for (const [key, value] of Object.entries(props)) {
     if (!reservedKeys.has(key)) {
-      target[key] = value;
+      kept[key] = value;
     }
   }
+  return kept;
 }
 function buildSelectableNode(row, alias) {
   const id = row[`${alias}_id`];
@@ -5044,9 +5316,9 @@ function buildSelectableNode(row, alias) {
       createdAt,
       updatedAt,
       deletedAt
-    }
+    },
+    ...propsExcludingReserved(rawProps, RESERVED_NODE_KEYS)
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_NODE_KEYS);
   return result;
 }
 function buildSelectableNodeOrUndefined(row, alias) {
@@ -5086,15 +5358,14 @@ function buildSelectableEdge(row, alias) {
       createdAt,
       updatedAt,
       deletedAt
-    }
+    },
+    ...propsExcludingReserved(rawProps, RESERVED_EDGE_KEYS)
   };
-  assignPropsExcludingReserved(result, rawProps, RESERVED_EDGE_KEYS);
   return result;
 }
 function buildSelectContext(row, startAlias, traversals) {
-  const context = {
-    [startAlias]: buildSelectableNode(row, startAlias)
-  };
+  const context = createDataKeyedBag();
+  context[startAlias] = buildSelectableNode(row, startAlias);
   for (const traversal of traversals) {
     const nodeAlias = traversal.nodeAlias;
     const edgeAlias = traversal.edgeAlias;
@@ -5110,7 +5381,7 @@ function buildSelectContext(row, startAlias, traversals) {
       }
     }
   }
-  return context;
+  return { ...context };
 }
 function mapResults(rows, startAlias, traversals, selectFunction) {
   return rows.map((row) => {
@@ -5408,14 +5679,13 @@ var FieldAccessTracker = class {
   }
 };
 function createTrackingContext(state, tracker, options) {
-  const context = {
-    [state.startAlias]: createNodeTrackingProxy(
-      state.startAlias,
-      state.startKinds,
-      tracker,
-      options
-    )
-  };
+  const context = createDataKeyedBag();
+  context[state.startAlias] = createNodeTrackingProxy(
+    state.startAlias,
+    state.startKinds,
+    tracker,
+    options
+  );
   for (const traversal of state.traversals) {
     const edgeKindNames = mergeEdgeKinds(traversal);
     const optionalAbsent = options.optionalTraversalAliases === "absent" && traversal.optional;
@@ -5441,7 +5711,7 @@ function createTrackingContext(state, tracker, options) {
       }
     }
   }
-  return context;
+  return { ...context };
 }
 function createNodeTrackingProxy(alias, kindNames, tracker, options) {
   return new Proxy(
@@ -5449,9 +5719,10 @@ function createNodeTrackingProxy(alias, kindNames, tracker, options) {
     {
       get: (_, property) => {
         if (typeof property === "symbol") return;
-        if (property === "then") return;
-        if (property === "toJSON") return;
-        if (OBJECT_PROTOTYPE_PROPERTIES.has(property)) {
+        if (isInteropProbeKey(property) && !options.schemaIntrospector.hasDeclaredField(kindNames, property)) {
+          return;
+        }
+        if (OBJECT_PROTOTYPE_PROPERTIES.has(property) && !options.schemaIntrospector.hasDeclaredField(kindNames, property)) {
           if (property === "constructor") return Object;
           if (property === "__proto__") return Object.prototype;
           return Reflect.get(Object.prototype, property);
@@ -5482,9 +5753,16 @@ function createEdgeTrackingProxy(alias, edgeKindNames, tracker, options) {
     {
       get: (_, property) => {
         if (typeof property === "symbol") return;
-        if (property === "then") return;
-        if (property === "toJSON") return;
-        if (OBJECT_PROTOTYPE_PROPERTIES.has(property)) {
+        if (isInteropProbeKey(property) && !options.schemaIntrospector.hasDeclaredEdgeField(
+          edgeKindNames,
+          property
+        )) {
+          return;
+        }
+        if (OBJECT_PROTOTYPE_PROPERTIES.has(property) && !options.schemaIntrospector.hasDeclaredEdgeField(
+          edgeKindNames,
+          property
+        )) {
           if (property === "constructor") return Object;
           if (property === "__proto__") return Object.prototype;
           return Reflect.get(Object.prototype, property);
@@ -5762,7 +6040,7 @@ function buildAliasPlans(state, selectiveFields, schemaIntrospector) {
   return plans.toSorted((a, b) => compareStrings(a.alias, b.alias));
 }
 function buildSelectiveContext(row, plans, traversals) {
-  const context = {};
+  const context = createDataKeyedBag();
   for (const plan of plans) {
     const value = plan.optional && plan.idOutputName !== void 0 ? buildOptionalAliasValue(row, plan) : buildRequiredAliasValue(row, plan);
     context[plan.alias] = value;
@@ -5778,7 +6056,7 @@ function buildSelectiveContext(row, plans, traversals) {
       }
     }
   }
-  return context;
+  return { ...context };
 }
 function buildOptionalAliasValue(row, plan) {
   if (plan.idOutputName === void 0) {
@@ -5791,17 +6069,16 @@ function buildOptionalAliasValue(row, plan) {
   return buildRequiredAliasValue(row, plan);
 }
 function buildRequiredAliasValue(row, plan) {
-  const base = {
-    [SELECTABLE_ALIAS_MARKER]: {
-      alias: plan.alias,
-      kind: plan.kind
-    }
+  const base = createDataKeyedBag();
+  base[SELECTABLE_ALIAS_MARKER] = {
+    alias: plan.alias,
+    kind: plan.kind
   };
   for (const field2 of plan.systemFields) {
     base[field2.field] = nullToUndefined(row[field2.outputName]);
   }
   if (plan.metaFields.length > 0) {
-    const meta = {};
+    const meta = createDataKeyedBag();
     for (const field2 of plan.metaFields) {
       meta[field2.metaKey] = nullToUndefined(row[field2.outputName]);
     }
@@ -5814,23 +6091,26 @@ function buildRequiredAliasValue(row, plan) {
   return createGuardedProxy(base, plan.alias);
 }
 function createGuardedProxy(target, debugPath) {
-  return new Proxy(target, {
-    get: (object, property, receiver) => {
-      if (typeof property === "symbol") {
-        return Reflect.get(object, property, receiver);
-      }
-      if (property === "then" || property === "toJSON") {
-        return;
-      }
-      if (property in object) {
-        return Reflect.get(object, property, receiver);
-      }
-      if (property in Object.prototype) {
-        return Reflect.get(Object.prototype, property, receiver);
+  return new Proxy(
+    { ...target },
+    {
+      get: (object, property, receiver) => {
+        if (typeof property === "symbol") {
+          return Reflect.get(object, property, receiver);
+        }
+        if (hasOwnKey(object, property)) {
+          return Reflect.get(object, property, receiver);
+        }
+        if (isInteropProbeKey(property)) {
+          return;
+        }
+        if (property in Object.prototype) {
+          return Reflect.get(Object.prototype, property, receiver);
+        }
+        throw new MissingSelectiveFieldError(debugPath, property);
       }
-      throw new MissingSelectiveFieldError(debugPath, property);
     }
-  });
+  );
 }
 
 // src/query/builder/read-instant-template.ts
@@ -5879,7 +6159,7 @@ function fillTemplateParams(params, bindings, dialect, listParameters = EMPTY_LI
       readInstant ??= nowIso();
       return readInstant;
     }
-    const value = bindings[name];
+    const value = readOwnProperty(bindings, name);
     if (value === void 0) {
       throw new ConfigurationError(`Missing binding for parameter "${name}"`, {
         parameterName: name
@@ -5946,7 +6226,7 @@ function substitutePredicateExpression(expr, bindings) {
     }
     case "string_op": {
       if (isParameterRef(expr.pattern)) {
-        const value = bindings[expr.pattern.name];
+        const value = readOwnProperty(bindings, expr.pattern.name);
         if (value === void 0) {
           throw new ConfigurationError(
             `Missing binding for parameter "${expr.pattern.name}"`,
@@ -6020,7 +6300,7 @@ function substitutePredicateExpression(expr, bindings) {
   }
 }
 function resolveBinding(bindings, name) {
-  const value = bindings[name];
+  const value = readOwnProperty(bindings, name);
   if (value === void 0) {
     throw new ConfigurationError(`Missing binding for parameter "${name}"`, {
       parameterName: name
@@ -6300,7 +6580,7 @@ function validateBindings(bindings, metadata) {
   const { names: expectedNames, stringOpParameters, listParameters } = metadata;
   const missing = [];
   for (const name of expectedNames) {
-    if (bindings[name] === void 0) {
+    if (readOwnProperty(bindings, name) === void 0) {
       missing.push(name);
     }
   }
@@ -6320,7 +6600,7 @@ function validateBindings(bindings, metadata) {
     );
   }
   for (const name of expectedNames) {
-    const value = bindings[name];
+    const value = readOwnProperty(bindings, name);
     if (listParameters.has(name)) {
       validateListBinding(name, value, listParameters.get(name));
       continue;
@@ -6711,6 +6991,7 @@ function buildCompileOptions(config) {
     dialect: config.dialect ?? "sqlite",
     schema: config.schema,
     windowFunctions: config.backend?.capabilities.windowFunctions ?? true,
+    identitySameIdAcrossKinds: config.identitySameIdAcrossKinds,
     ...fulltextStrategy === void 0 ? {} : {
       fulltextStrategy,
       fulltextLanguages: buildFulltextLanguages(config.registry)
@@ -7460,7 +7741,9 @@ var ExecutableQuery = class _ExecutableQuery {
         optionalNodeAliases.add(traversal.nodeAlias);
       }
     }
-    const cursorContext = {};
+    const cursorContext = /* @__PURE__ */ Object.create(
+      null
+    );
     for (const spec of this.#paginationOrderBy()) {
       const alias = spec.field.alias;
       const jsonPointer2 = spec.field.jsonPointer;
@@ -7518,7 +7801,9 @@ var ExecutableQuery = class _ExecutableQuery {
         if (typeof existing_ === "object" && existing_ !== null) {
           current = existing_;
         } else {
-          const created = {};
+          const created = /* @__PURE__ */ Object.create(
+            null
+          );
           current[segment] = created;
           current = created;
         }
@@ -7532,7 +7817,7 @@ var ExecutableQuery = class _ExecutableQuery {
     if (typeof existing === "object" && existing !== null) {
       return existing;
     }
-    const created = {};
+    const created = /* @__PURE__ */ Object.create(null);
     cursorContext[alias] = created;
     return created;
   }
@@ -7880,7 +8165,7 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
    */
   #mapResults(rows) {
     return rows.map((row) => {
-      const result = {};
+      const result = createDataKeyedBag();
       for (const key of Object.keys(this.#fields)) {
         const field2 = this.#fields[key];
         if (!field2) continue;
@@ -7891,7 +8176,7 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
         }
         result[key] = normalizeFieldValue(field2, value);
       }
-      return result;
+      return { ...result };
     });
   }
 };
@@ -8004,9 +8289,10 @@ var TraversalBuilder = class _TraversalBuilder {
   #direction;
   #fromAlias;
   #optional;
+  #includeIdentityMembers;
   #variableLength;
   #pendingEdgePredicates;
-  constructor(config, state, edgeKinds, edgeAlias, direction, fromAlias, inverseEdgeKinds = [], optional = false, variableLength = DEFAULT_VARIABLE_LENGTH_STATE, pendingEdgePredicates = []) {
+  constructor(config, state, edgeKinds, edgeAlias, direction, fromAlias, inverseEdgeKinds = [], optional = false, variableLength = DEFAULT_VARIABLE_LENGTH_STATE, pendingEdgePredicates = [], includeIdentityMembers = false) {
     this.#config = config;
     this.#state = state;
     this.#edgeKinds = edgeKinds;
@@ -8015,6 +8301,7 @@ var TraversalBuilder = class _TraversalBuilder {
     this.#direction = direction;
     this.#fromAlias = fromAlias;
     this.#optional = optional;
+    this.#includeIdentityMembers = includeIdentityMembers;
     this.#variableLength = variableLength;
     this.#pendingEdgePredicates = pendingEdgePredicates;
   }
@@ -8062,7 +8349,8 @@ var TraversalBuilder = class _TraversalBuilder {
           ...depthAlias !== void 0 && { depthAlias }
         }
       },
-      this.#pendingEdgePredicates
+      this.#pendingEdgePredicates,
+      this.#includeIdentityMembers
     );
   }
   /**
@@ -8091,7 +8379,8 @@ var TraversalBuilder = class _TraversalBuilder {
       this.#inverseEdgeKinds,
       this.#optional,
       this.#variableLength,
-      [...this.#pendingEdgePredicates, newPredicate]
+      [...this.#pendingEdgePredicates, newPredicate],
+      this.#includeIdentityMembers
     );
   }
   /**
@@ -8172,12 +8461,16 @@ var TraversalBuilder = class _TraversalBuilder {
     return new Proxy({}, {
       get: (_, property) => {
         if (typeof property === "symbol") return;
-        if (property === "then") return;
-        if (property === "toJSON") return;
         if (property === "id") return idAccessor;
         if (property === "kind") return kindAccessor;
         if (property === "fromId") return fromIdAccessor;
         if (property === "toId") return toIdAccessor;
+        if (isInteropProbeKey(property) && !this.#config.schemaIntrospector.hasDeclaredEdgeField(
+          allEdgeKinds,
+          property
+        )) {
+          return;
+        }
         return buildFieldAccessor(property);
       }
     });
@@ -8223,7 +8516,8 @@ var TraversalBuilder = class _TraversalBuilder {
       nodeKinds: kinds,
       joinFromAlias: this.#fromAlias,
       joinEdgeField: this.#direction === "out" ? "from_id" : "to_id",
-      optional: this.#optional
+      optional: this.#optional,
+      ...this.#includeIdentityMembers ? { includeIdentityMembers: true } : {}
     };
     const baseTraversal = this.#inverseEdgeKinds.length > 0 ? { ...traversalBase, inverseEdgeKinds: this.#inverseEdgeKinds } : traversalBase;
     const traversal = this.#variableLength.enabled ? {
@@ -8514,6 +8808,7 @@ var QueryBuilder = class _QueryBuilder {
   traverse(edgeKind, edgeAlias, options) {
     validateSqlIdentifier(edgeAlias);
     const direction = options?.direction ?? "out";
+    this.#assertIdentityTraversalAllowed(options);
     const expansion = options?.expand ?? this.#config.defaultTraversalExpansion;
     const includeImplyingEdges = expansion === "implying" || expansion === "all";
     const includeInverseEdges = expansion === "inverse" || expansion === "all";
@@ -8531,7 +8826,12 @@ var QueryBuilder = class _QueryBuilder {
       direction,
       fromAlias,
       inverseEdgeKinds,
-      false
+      false,
+      void 0,
+      // variableLength — default
+      void 0,
+      // pendingEdgePredicates — default
+      options?.includeIdentityMembers ?? false
     );
   }
   /**
@@ -8544,6 +8844,7 @@ var QueryBuilder = class _QueryBuilder {
   optionalTraverse(edgeKind, edgeAlias, options) {
     validateSqlIdentifier(edgeAlias);
     const direction = options?.direction ?? "out";
+    this.#assertIdentityTraversalAllowed(options);
     const expansion = options?.expand ?? this.#config.defaultTraversalExpansion;
     const includeImplyingEdges = expansion === "implying" || expansion === "all";
     const includeInverseEdges = expansion === "inverse" || expansion === "all";
@@ -8561,7 +8862,12 @@ var QueryBuilder = class _QueryBuilder {
       direction,
       fromAlias,
       inverseEdgeKinds,
-      true
+      true,
+      void 0,
+      // variableLength — default
+      void 0,
+      // pendingEdgePredicates — default
+      options?.includeIdentityMembers ?? false
     );
   }
   /**
@@ -8586,6 +8892,7 @@ var QueryBuilder = class _QueryBuilder {
       });
     }
     const direction = options?.direction ?? "out";
+    this.#assertIdentityTraversalAllowed(options);
     const expansion = options?.expand ?? this.#config.defaultTraversalExpansion;
     const includeImplyingEdges = expansion === "implying" || expansion === "all";
     const includeInverseEdges = expansion === "inverse" || expansion === "all";
@@ -8610,7 +8917,12 @@ var QueryBuilder = class _QueryBuilder {
       direction,
       fromAlias,
       inverseEdgeKinds,
-      optional
+      optional,
+      void 0,
+      // variableLength — default
+      void 0,
+      // pendingEdgePredicates — default
+      options?.includeIdentityMembers ?? false
     );
   }
   /**
@@ -8912,11 +9224,15 @@ var QueryBuilder = class _QueryBuilder {
     return new Proxy({}, {
       get: (_, property) => {
         if (typeof property === "symbol") return;
-        if (property === "then") return;
-        if (property === "toJSON") return;
         if (property === "id") return idAccessor;
         if (property === "kind") return kindAccessor;
         if (property === "$fulltext") return fulltextAccessor;
+        if (isInteropProbeKey(property) && !(kindNames !== void 0 && this.#config.schemaIntrospector.hasDeclaredField(
+          kindNames,
+          property
+        ))) {
+          return;
+        }
         return this.#getFieldBuilderForProperty(kindNames, property, alias);
       }
     });
@@ -8925,6 +9241,21 @@ var QueryBuilder = class _QueryBuilder {
     if (!kindNames) return false;
     return this.#config.schemaIntrospector.hasSearchableField(kindNames);
   }
+  /**
+   * Guards `includeIdentityMembers` against a non-identity-enabled builder.
+   */
+  #assertIdentityTraversalAllowed(options) {
+    if (!options?.includeIdentityMembers || this.#config.identityEnabled) {
+      return;
+    }
+    throw new ConfigurationError(
+      "includeIdentityMembers requires an identity-enabled graph registry.",
+      { code: "IDENTITY_NOT_ENABLED", graphId: this.#config.graphId },
+      {
+        suggestion: "Enable defineGraph(...).identity and build the registry from that graph."
+      }
+    );
+  }
   #expandTraversalEdgeKinds(edgeKind, includeImplyingEdges) {
     return includeImplyingEdges ? this.#config.registry.expandImplyingEdges(edgeKind) : [edgeKind];
   }
@@ -9005,12 +9336,16 @@ var QueryBuilder = class _QueryBuilder {
     return new Proxy({}, {
       get: (_, property) => {
         if (typeof property === "symbol") return;
-        if (property === "then") return;
-        if (property === "toJSON") return;
         if (property === "id") return idAccessor;
         if (property === "kind") return kindAccessor;
         if (property === "fromId") return fromIdAccessor;
         if (property === "toId") return toIdAccessor;
+        if (isInteropProbeKey(property) && !(edgeKindNames !== void 0 && this.#config.schemaIntrospector.hasDeclaredEdgeField(
+          edgeKindNames,
+          property
+        ))) {
+          return;
+        }
         return this.#getFieldBuilderForEdgeProperty(
           edgeKindNames,
           property,
@@ -9464,11 +9799,31 @@ function createQueryBuilderWithContext(graphId, registry, options) {
     registry.nodeKinds,
     registry.edgeKinds
   );
+  if (options?.identityEnabled === true && registry.identity === void 0) {
+    throw new ConfigurationError(
+      "Identity-aware query compilation requires an identity-enabled graph registry.",
+      { code: "IDENTITY_NOT_ENABLED", graphId },
+      {
+        suggestion: "Build the registry from a graph whose defineGraph(...) config includes identity."
+      }
+    );
+  }
+  if (options?.identitySameIdAcrossKinds !== void 0 && registry.identity === void 0) {
+    throw new ConfigurationError(
+      "identitySameIdAcrossKinds requires an identity-enabled graph registry.",
+      { code: "IDENTITY_NOT_ENABLED", graphId },
+      {
+        suggestion: "Configure sameIdAcrossKinds on defineGraph(...).identity instead."
+      }
+    );
+  }
   const config = {
     graphId,
     registry,
     schemaIntrospector,
     defaultTraversalExpansion: options?.defaultTraversalExpansion ?? "inverse",
+    identityEnabled: options?.identityEnabled ?? registry.identity !== void 0,
+    identitySameIdAcrossKinds: options?.identitySameIdAcrossKinds ?? registry.identity?.sameIdAcrossKinds ?? "fold",
     ...options?.backend !== void 0 && { backend: options.backend },
     ...options?.dialect !== void 0 && { dialect: options.dialect },
     ...options?.schema !== void 0 && { schema: options.schema }
@@ -9543,11 +9898,32 @@ function isPropsObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function rebuildFulltextIndex(ctx, nodeKind, options) {
-  const { backend, registry } = ctx;
-  if (!backend.upsertFulltext || !backend.deleteFulltext) {
-    throw new ConfigurationError(
-      "Backend does not support fulltext; cannot rebuild index",
-      { backend: backend.dialect, capability: "fulltext" }
+  const { backend } = ctx;
+  return runFulltextRebuild(
+    {
+      read: backend,
+      runPage: (write) => runOptionallyInTransaction(backend, write)
+    },
+    ctx,
+    nodeKind,
+    options
+  );
+}
+async function repopulateFulltextInTransaction(ctx, target, options = {}) {
+  return runFulltextRebuild(
+    { read: target, runPage: (write) => write(target) },
+    ctx,
+    void 0,
+    options
+  );
+}
+async function runFulltextRebuild(driver, ctx, nodeKind, options) {
+  const { registry } = ctx;
+  const backend = driver.read;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    throw new ConfigurationError(
+      "Backend does not support fulltext; cannot rebuild index",
+      { backend: backend.dialect, capability: "fulltext" }
     );
   }
   const pageSize = validatePageSize(options.pageSize);
@@ -9623,7 +9999,7 @@ async function rebuildFulltextIndex(ctx, nodeKind, options) {
           }
         }
       };
-      await runOptionallyInTransaction(backend, writePage);
+      await driver.runPage(writePage);
       processed += rows.length;
       upserted += pageResult.toUpsert.length;
       cleared += pageResult.toDelete.length;
@@ -10465,7 +10841,8 @@ function classifyModifications(existing, next) {
     }
   };
   for (const [name, nextNode] of Object.entries(next.nodes ?? {})) {
-    const existingNode = existing.nodes?.[name];
+    const existingNodes = existing.nodes;
+    const existingNode = existingNodes !== void 0 && hasOwnKey(existingNodes, name) ? existingNodes[name] : void 0;
     if (existingNode === void 0) continue;
     classifyNode(name, existingNode, nextNode, {
       recordIncompatible,
@@ -10475,7 +10852,8 @@ function classifyModifications(existing, next) {
     });
   }
   for (const [name, nextEdge] of Object.entries(next.edges ?? {})) {
-    const existingEdge = existing.edges?.[name];
+    const existingEdges = existing.edges;
+    const existingEdge = existingEdges !== void 0 && hasOwnKey(existingEdges, name) ? existingEdges[name] : void 0;
     if (existingEdge === void 0) continue;
     classifyEdge(name, existingEdge, nextEdge, {
       recordIncompatible,
@@ -10869,13 +11247,17 @@ function resolveMaxHops(rawMaxHops, fallback, optionName) {
 }
 function resolveMaxIterations(value, fallback, algorithm) {
   const maxIterations = value ?? fallback;
-  if (!Number.isSafeInteger(maxIterations) || maxIterations < 1) {
+  assertPositiveSafeIntegerOption(maxIterations, algorithm, "maxIterations");
+  return maxIterations;
+}
+function assertPositiveSafeIntegerOption(value, algorithm, optionName) {
+  if (value === void 0) return;
+  if (!Number.isSafeInteger(value) || value < 1) {
     throw new ConfigurationError(
-      `${algorithm} maxIterations must be a positive safe integer, got ${String(maxIterations)}.`,
-      { maxIterations }
+      `${algorithm} ${optionName} must be a positive safe integer, got ${String(value)}.`,
+      { [optionName]: value }
     );
   }
-  return maxIterations;
 }
 function assertEdgeKinds(edges) {
   if (edges.length === 0) {
@@ -10885,16 +11267,6 @@ function assertEdgeKinds(edges) {
     );
   }
 }
-function compileNodeKindSeedFilter(nodeKinds) {
-  if (nodeKinds === void 0) return sql`TRUE`;
-  return compileKindFilter(sql.raw("n.kind"), nodeKinds);
-}
-function normalizeNodeKinds(nodeKinds) {
-  if (nodeKinds === void 0) return void 0;
-  return [...new Set(nodeKinds)].toSorted(
-    (left, right) => compareCodePoints(left, right)
-  );
-}
 function assertGraphAnalyticsSupported(ctx, algorithm, options = {}) {
   const graphAnalytics = ctx.backend.capabilities.graphAnalytics?.supported === true;
   const windowFunctions = ctx.backend.capabilities.windowFunctions;
@@ -10970,6 +11342,56 @@ async function countWorkingTableRows(context) {
   );
   return Number(rows[0]?.count ?? 0);
 }
+async function seedWorkingTableFromNodes(context, nodeKinds, seedColumns) {
+  if (nodeKinds?.length === 0) return;
+  const additionalColumns = seedColumns.length === 0 ? sql.empty() : sql`, ${sql.join(
+    seedColumns.map((column) => sql.identifier(column.name)),
+    sql`, `
+  )}`;
+  const additionalValues = seedColumns.length === 0 ? sql.empty() : sql`, ${sql.join(
+    seedColumns.map((column) => column.value),
+    sql`, `
+  )}`;
+  const compileSeedStatement = (nodeKindFilter) => {
+    return sql`
+      INSERT INTO ${context.workingTable}
+        (graph_id, run_id, node_id, node_kind${additionalColumns})
+      SELECT ${context.graphId}, ${context.runId}, n.id, n.kind${additionalValues}
+      FROM ${context.operation.schema.nodesTable} n
+      WHERE n.graph_id = ${context.graphId}
+        AND ${nodeKindFilter}
+        AND ${context.operation.nodeTemporalFilter}
+    `;
+  };
+  const fixedStatement = compileSeedStatement(sql`TRUE`);
+  const parameterLimit = context.operation.backend.capabilities.maxBindParameters ?? DEFAULT_MAX_BIND_PARAMETERS;
+  const fixedParameterCount = countBindParameters(fixedStatement);
+  const kindBindBudget = parameterLimit - fixedParameterCount;
+  if (kindBindBudget < (nodeKinds === void 0 ? 0 : 1)) {
+    throw new ConfigurationError(
+      "An iterative graph operation cannot fit its node-kind initialization within the backend bind-parameter limit.",
+      { fixedParameterCount, parameterLimit }
+    );
+  }
+  if (nodeKinds === void 0) {
+    await context.executeTemporary(fixedStatement);
+    return;
+  }
+  const normalizedKinds = [...new Set(nodeKinds)].toSorted(
+    (left, right) => compareCodePoints(left, right)
+  );
+  for (const kindChunk of chunkValues(normalizedKinds, kindBindBudget)) {
+    await context.executeTemporary(
+      compileSeedStatement(compileKindFilter(sql.raw("n.kind"), kindChunk))
+    );
+  }
+}
+function countBindParameters(fragment) {
+  return fragment.chunks.reduce(
+    (count2, chunk2) => count2 + (chunk2.kind === "parameter" || chunk2.kind === "placeholder" ? 1 : 0),
+    0
+  );
+}
 var DEFAULT_MAX_BIND_PARAMETERS = 999;
 var RESERVED_TEMPORAL_BIND_PARAMETERS_PER_BRANCH = 12;
 var RESERVED_WEIGHT_BIND_PARAMETERS_PER_BRANCH = 4;
@@ -11025,64 +11447,101 @@ async function runIterativeGraphOperation(ctx, options, plan) {
     accessMode: "read_only",
     temporaryWrites: INTERNAL_TEMPORARY_WRITES
   };
-  return ctx.backend.transaction(async (backend) => {
-    const temporaryBackend = requireTemporaryStatements(backend);
-    const runId = generateId();
-    const workingTable = sql.identifier(
-      `typegraph_iterative_${runId.replaceAll("-", "_")}`
-    );
-    const context = {
-      operation: createOperation(ctx, options, temporaryBackend),
-      backend: temporaryBackend,
-      workingTable,
-      graphId: ctx.graphId,
-      runId,
-      executeTemporary: async (query) => {
-        await temporaryBackend.executeTemporaryStatement(
-          asCompiledTemporaryStatementSql(query)
-        );
-      }
-    };
-    if (context.operation.workingMemory !== void 0) {
-      const workingMemoryStatement = ctx.dialect.setTransactionWorkingMemory(
-        context.operation.workingMemory
+  const rounds = { started: false };
+  try {
+    return await ctx.backend.transaction(async (backend) => {
+      rounds.started = true;
+      return runWorkingTableRounds(ctx, options, plan, backend);
+    }, transactionOptions);
+  } catch (error) {
+    if (rounds.started || ctx.backend.dialect !== "postgres") throw error;
+    const sqlState = postgresReadWriteRefusedSqlState(error);
+    if (sqlState === void 0) throw error;
+    throw temporaryTableCapabilityError(ctx, plan.algorithm, sqlState, error);
+  }
+}
+function temporaryTableCapabilityError(ctx, algorithm, sqlState, cause) {
+  const error = new UnsupportedBackendCapabilityError(
+    algorithm,
+    "graphAnalytics",
+    {
+      dialect: ctx.backend.dialect,
+      supported: false,
+      requirement: "transaction-local temporary tables",
+      sqlState
+    },
+    "Run graph analytics on a writable PostgreSQL primary with a role that has the TEMP privilege."
+  );
+  Object.defineProperty(error, "cause", {
+    configurable: true,
+    value: cause,
+    writable: true
+  });
+  return error;
+}
+async function runWorkingTableRounds(ctx, options, plan, backend) {
+  const temporaryBackend = requireTemporaryStatements(backend);
+  const runId = generateId();
+  const workingTable = sql.identifier(
+    `typegraph_iterative_${runId.replaceAll("-", "_")}`
+  );
+  const context = {
+    operation: createOperation(ctx, options, temporaryBackend),
+    backend: temporaryBackend,
+    workingTable,
+    graphId: ctx.graphId,
+    runId,
+    executeTemporary: async (query) => {
+      await temporaryBackend.executeTemporaryStatement(
+        asCompiledTemporaryStatementSql(query)
       );
-      if (workingMemoryStatement !== void 0) {
-        await context.executeTemporary(workingMemoryStatement);
-      }
     }
+  };
+  if (context.operation.workingMemory !== void 0) {
+    const workingMemoryStatement = ctx.dialect.setTransactionWorkingMemory(
+      context.operation.workingMemory
+    );
+    if (workingMemoryStatement !== void 0) {
+      await context.executeTemporary(workingMemoryStatement);
+    }
+  }
+  try {
     await context.executeTemporary(plan.createWorkingTable(context));
-    let operationFailure;
-    try {
-      let state = await plan.initialize(context);
-      let analyzedRowCount = await refreshWorkingTableStatistics(
-        context,
-        state.workingTableSize
-      );
-      for (let iteration = 1; iteration <= plan.maxIterations && !plan.hasConverged(state); iteration++) {
-        state = await plan.runRound(context, state, iteration);
-        if (iteration < plan.maxIterations && !plan.hasConverged(state)) {
-          analyzedRowCount = await refreshWorkingTableStatistics(
-            context,
-            state.workingTableSize,
-            analyzedRowCount
-          );
-        }
-      }
-      if (!plan.hasConverged(state)) {
-        throw new GraphAlgorithmConvergenceError(
-          plan.algorithm,
-          plan.maxIterations
+  } catch (error) {
+    const sqlState = ctx.backend.dialect === "postgres" ? postgresTemporaryTableUnavailableSqlState(error) : void 0;
+    if (sqlState === void 0) throw error;
+    throw temporaryTableCapabilityError(ctx, plan.algorithm, sqlState, error);
+  }
+  let operationFailure;
+  try {
+    let state = await plan.initialize(context);
+    let analyzedRowCount = await refreshWorkingTableStatistics(
+      context,
+      state.workingTableSize
+    );
+    for (let iteration = 1; iteration <= plan.maxIterations && !plan.hasConverged(state); iteration++) {
+      state = await plan.runRound(context, state, iteration);
+      if (iteration < plan.maxIterations && !plan.hasConverged(state)) {
+        analyzedRowCount = await refreshWorkingTableStatistics(
+          context,
+          state.workingTableSize,
+          analyzedRowCount
         );
       }
-      return await plan.extractResult(context, state);
-    } catch (error) {
-      operationFailure = { error };
-      throw error;
-    } finally {
-      await cleanupWorkingTables(context, plan.cleanup, operationFailure);
     }
-  }, transactionOptions);
+    if (!plan.hasConverged(state)) {
+      throw new GraphAlgorithmConvergenceError(
+        plan.algorithm,
+        plan.maxIterations
+      );
+    }
+    return await plan.extractResult(context, state);
+  } catch (error) {
+    operationFailure = { error };
+    throw error;
+  } finally {
+    await cleanupWorkingTables(context, plan.cleanup, operationFailure);
+  }
 }
 function shouldRefreshWorkingTableStatistics(workingTableSize, analyzedRowCount) {
   if (workingTableSize < WORKING_TABLE_ANALYZE_MINIMUM_ROWS) return false;
@@ -11385,7 +11844,6 @@ async function executeLabelPropagation(ctx, options) {
     DEFAULT_LABEL_PROPAGATION_MAX_ITERATIONS,
     "labelPropagation"
   );
-  const nodeKinds = normalizeNodeKinds(options.nodeKinds);
   const policy = {
     detector: createOscillationDetector(),
     maxIterations,
@@ -11401,7 +11859,7 @@ async function executeLabelPropagation(ctx, options) {
     algorithm: "labelPropagation",
     maxIterations,
     createWorkingTable,
-    initialize: (context) => initializeWorkingTables(context, nodeKinds),
+    initialize: (context) => initializeWorkingTables(context, options.nodeKinds),
     runRound: (context, state, iteration) => runLabelPropagationRound(context, state, iteration, policy),
     hasConverged(state) {
       return state.changedCount === 0 || state.completed;
@@ -11466,26 +11924,21 @@ function activeIndexIdentifier(context) {
   );
 }
 async function initializeWorkingTables(context, nodeKinds) {
-  const { operation, workingTable, graphId, runId } = context;
-  const nodeKindFilter = compileNodeKindSeedFilter(nodeKinds);
-  await context.executeTemporary(sql`
-    INSERT INTO ${workingTable}
-      (graph_id, run_id, node_id, node_kind, label_id, label_kind,
-       next_label_id, next_label_kind, changed_round, active_round)
-    SELECT
-      ${graphId}, ${runId}, n.id, n.kind, n.id, n.kind, n.id, n.kind, 0, 1
-    FROM ${operation.schema.nodesTable} n
-    WHERE n.graph_id = ${graphId}
-      AND ${nodeKindFilter}
-      AND ${operation.nodeTemporalFilter}
-  `);
+  await seedWorkingTableFromNodes(context, nodeKinds, [
+    { name: "label_id", value: sql.raw("n.id") },
+    { name: "label_kind", value: sql.raw("n.kind") },
+    { name: "next_label_id", value: sql.raw("n.id") },
+    { name: "next_label_kind", value: sql.raw("n.kind") },
+    { name: "changed_round", value: sql.raw("0") },
+    { name: "active_round", value: sql.raw("1") }
+  ]);
   await context.executeTemporary(sql`
     CREATE INDEX ${frontierIndexIdentifier(context)}
-    ON ${workingTable} (graph_id, run_id, changed_round)
+    ON ${context.workingTable} (graph_id, run_id, changed_round)
   `);
   await context.executeTemporary(sql`
     CREATE INDEX ${activeIndexIdentifier(context)}
-    ON ${workingTable} (graph_id, run_id, active_round)
+    ON ${context.workingTable} (graph_id, run_id, active_round)
   `);
   const neighborTable = neighborTableIdentifier(context);
   await context.executeTemporary(sql`
@@ -11497,10 +11950,10 @@ async function initializeWorkingTables(context, nodeKinds) {
       PRIMARY KEY (target_kind, target_id, neighbor_kind, neighbor_id)
     )
   `);
-  for (const edgeKinds of operation.edgeKindChunks) {
+  for (const edgeKinds of context.operation.edgeKindChunks) {
     await materializeChunkNeighbors(context, edgeKinds);
   }
-  const analyzeNeighbors = operation.ctx.dialect.analyzeTemporaryTable(neighborTable);
+  const analyzeNeighbors = context.operation.ctx.dialect.analyzeTemporaryTable(neighborTable);
   if (analyzeNeighbors !== void 0) {
     await context.executeTemporary(analyzeNeighbors);
   }
@@ -11742,7 +12195,7 @@ function executePageRankOperation(ctx, options, seeds) {
     hasConverged(state) {
       return state.maximumChange <= resolved.tolerance;
     },
-    extractResult: extractScores
+    extractResult: (context, state) => extractScores(context, state, resolved.topK)
   });
 }
 function resolvePageRankOptions(options, algorithm) {
@@ -11760,6 +12213,7 @@ function resolvePageRankOptions(options, algorithm) {
       { tolerance }
     );
   }
+  assertPositiveSafeIntegerOption(options.topK, algorithm, "topK");
   return {
     dampingFactor,
     tolerance,
@@ -11768,7 +12222,8 @@ function resolvePageRankOptions(options, algorithm) {
       DEFAULT_MAX_ITERATIONS,
       algorithm
     ),
-    nodeKinds: normalizeNodeKinds(options.nodeKinds)
+    nodeKinds: options.nodeKinds,
+    topK: options.topK
   };
 }
 function normalizeSeeds(seeds) {
@@ -11841,17 +12296,12 @@ function createWorkingTable2(context) {
 }
 async function initializeWorkingTable(context, nodeKinds, seeds) {
   const { operation, workingTable, graphId, runId } = context;
-  const nodeKindFilter = compileNodeKindSeedFilter(nodeKinds);
-  await context.executeTemporary(sql`
-    INSERT INTO ${workingTable}
-      (graph_id, run_id, node_id, node_kind, score, next_score,
-       personalization, out_weight)
-    SELECT ${graphId}, ${runId}, n.id, n.kind, 0.0, 0.0, 0.0, 0.0
-    FROM ${operation.schema.nodesTable} n
-    WHERE n.graph_id = ${graphId}
-      AND ${nodeKindFilter}
-      AND ${operation.nodeTemporalFilter}
-  `);
+  await seedWorkingTableFromNodes(context, nodeKinds, [
+    { name: "score", value: sql.raw("0.0") },
+    { name: "next_score", value: sql.raw("0.0") },
+    { name: "personalization", value: sql.raw("0.0") },
+    { name: "out_weight", value: sql.raw("0.0") }
+  ]);
   const workingTableSize = await countWorkingTableRows(context);
   if (workingTableSize === 0) {
     if (seeds !== void 0) {
@@ -12087,16 +12537,18 @@ async function readMaximumChange(context, sourceScoreColumn, targetScoreColumn)
   );
   return Number(rows[0]?.value ?? 0);
 }
-async function extractScores(context, state) {
+async function extractScores(context, state, topK) {
   const score = sql.identifier(state.activeScoreColumn);
   const nodeId = context.operation.ctx.dialect.binaryText(sql`node_id`);
   const nodeKind = context.operation.ctx.dialect.binaryText(sql`node_kind`);
+  const limitClause = topK === void 0 ? sql.empty() : sql`LIMIT ${topK}`;
   const rows = await context.backend.execute(
     asCompiledRowsSql(sql`
       SELECT node_id, node_kind, ${score} AS score
       FROM ${context.workingTable}
       WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
       ORDER BY ${score} DESC, ${nodeId}, ${nodeKind}
+      ${limitClause}
     `)
   );
   return rows.map((row) => ({
@@ -12679,7 +13131,11 @@ async function executeWeaklyConnectedComponents(ctx, options) {
     DEFAULT_WCC_MAX_ITERATIONS,
     "weaklyConnectedComponents"
   );
-  const nodeKinds = normalizeNodeKinds(options.nodeKinds);
+  assertPositiveSafeIntegerOption(
+    options.minComponentSize,
+    "weaklyConnectedComponents",
+    "minComponentSize"
+  );
   const traversalOptions = {
     edges: options.edges,
     direction: "both",
@@ -12690,12 +13146,12 @@ async function executeWeaklyConnectedComponents(ctx, options) {
     algorithm: "weaklyConnectedComponents",
     maxIterations,
     createWorkingTable: createWorkingTable4,
-    initialize: (context) => initializeWorkingTable2(context, nodeKinds),
+    initialize: (context) => initializeWorkingTable2(context, options.nodeKinds),
     runRound: runLabelPropagationRound2,
     hasConverged(state) {
       return state.changedCount === 0;
     },
-    extractResult: extractMemberships2
+    extractResult: (context) => extractMemberships2(context, options.minComponentSize)
   });
 }
 function createWorkingTable4(context) {
@@ -12715,22 +13171,16 @@ function createWorkingTable4(context) {
   `;
 }
 async function initializeWorkingTable2(context, nodeKinds) {
-  const { operation, workingTable, graphId, runId } = context;
-  const nodeKindFilter = compileNodeKindSeedFilter(nodeKinds);
-  await context.executeTemporary(sql`
-    INSERT INTO ${workingTable}
-      (graph_id, run_id, node_id, node_kind, label_id, label_kind,
-       next_label_id, next_label_kind, improved_round)
-    SELECT
-      ${graphId}, ${runId}, n.id, n.kind, n.id, n.kind, n.id, n.kind, 0
-    FROM ${operation.schema.nodesTable} n
-    WHERE n.graph_id = ${graphId}
-      AND ${nodeKindFilter}
-      AND ${operation.nodeTemporalFilter}
-  `);
+  await seedWorkingTableFromNodes(context, nodeKinds, [
+    { name: "label_id", value: sql.raw("n.id") },
+    { name: "label_kind", value: sql.raw("n.kind") },
+    { name: "next_label_id", value: sql.raw("n.id") },
+    { name: "next_label_kind", value: sql.raw("n.kind") },
+    { name: "improved_round", value: sql.raw("0") }
+  ]);
   await context.executeTemporary(sql`
     CREATE INDEX ${frontierIndexIdentifier(context)}
-    ON ${workingTable} (graph_id, run_id, improved_round)
+    ON ${context.workingTable} (graph_id, run_id, improved_round)
   `);
   const workingTableSize = await countWorkingTableRows(context);
   return { changedCount: workingTableSize, workingTableSize };
@@ -12830,24 +13280,32 @@ function applyNextLabels2(context, iteration) {
     `)
   );
 }
-async function extractMemberships2(context) {
+async function extractMemberships2(context, minComponentSize) {
   const { operation } = context;
-  const componentId = operation.ctx.dialect.binaryText(sql`label_id`);
-  const componentKind = operation.ctx.dialect.binaryText(sql`label_kind`);
+  const labelId = operation.ctx.dialect.binaryText(sql`label_id`);
+  const labelKind = operation.ctx.dialect.binaryText(sql`label_kind`);
+  const componentId = operation.ctx.dialect.binaryText(sql`component_id`);
+  const componentKind = operation.ctx.dialect.binaryText(sql`component_kind`);
   const nodeId = operation.ctx.dialect.binaryText(sql`node_id`);
   const nodeKind = operation.ctx.dialect.binaryText(sql`node_kind`);
+  const componentSizeFilter = minComponentSize === void 0 ? sql.empty() : sql`WHERE component_size >= ${minComponentSize}`;
   const rows = await context.backend.execute(
     asCompiledRowsSql(sql`
-      SELECT
-        node_id,
-        node_kind,
-        label_id AS component_id,
-        label_kind AS component_kind,
-        COUNT(*) OVER (
-          PARTITION BY ${componentKind}, ${componentId}
-        ) AS component_size
-      FROM ${context.workingTable}
-      WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+      WITH memberships AS (
+        SELECT
+          node_id,
+          node_kind,
+          label_id AS component_id,
+          label_kind AS component_kind,
+          COUNT(*) OVER (
+            PARTITION BY ${labelKind}, ${labelId}
+          ) AS component_size
+        FROM ${context.workingTable}
+        WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
+      )
+      SELECT node_id, node_kind, component_id, component_kind, component_size
+      FROM memberships
+      ${componentSizeFilter}
       ORDER BY ${componentId}, ${componentKind}, ${nodeId}, ${nodeKind}
     `)
   );
@@ -13428,6 +13886,87 @@ function createGraphAlgorithms(params) {
   };
 }
 
+// src/store/operations/edge-identity.ts
+function edgeIdentityFromRow(row) {
+  return {
+    kind: row.kind,
+    fromKind: row.from_kind,
+    fromId: row.from_id,
+    toKind: row.to_kind,
+    toId: row.to_id
+  };
+}
+function assertEdgeIdentityMatches(id, expected, actual, operation) {
+  const mismatches = [
+    expected.kind === actual.kind ? void 0 : "kind",
+    expected.fromKind === void 0 || expected.fromKind === actual.fromKind ? void 0 : "from.kind",
+    expected.fromId === void 0 || expected.fromId === actual.fromId ? void 0 : "from.id",
+    expected.toKind === void 0 || expected.toKind === actual.toKind ? void 0 : "to.kind",
+    expected.toId === void 0 || expected.toId === actual.toId ? void 0 : "to.id"
+  ].filter((path) => path !== void 0);
+  if (mismatches.length === 0) return;
+  throw new ValidationError(
+    `Edge "${id}" belongs to ${actual.kind} (${actual.fromKind}/${actual.fromId} -> ${actual.toKind}/${actual.toId}), not ${expected.kind}` + (expected.fromKind === void 0 ? "." : ` (${expected.fromKind}/${expected.fromId} -> ${expected.toKind}/${expected.toId}).`),
+    {
+      entityType: "edge",
+      kind: expected.kind,
+      operation,
+      id,
+      issues: mismatches.map((path) => ({
+        path,
+        message: "The edge id resolves to a different immutable identity",
+        code: EDGE_IDENTITY_MISMATCH_CODE
+      }))
+    },
+    {
+      suggestion: "Use the edge collection and endpoints that created this id, or choose a new id."
+    }
+  );
+}
+
+// src/store/collections/coalesce.ts
+function findRepeatedUpsertIds(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const repeated = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (seen.has(item.id)) repeated.add(item.id);
+    seen.add(item.id);
+  }
+  return repeated;
+}
+function windowFieldChanges(requested, stored) {
+  if (requested === void 0) {
+    return false;
+  }
+  if (!isCanonicalIsoDate(requested)) {
+    return true;
+  }
+  return !statedBoundMatchesStored(requested, stored);
+}
+function upsertWindowChanges(requested, current) {
+  return windowFieldChanges(requested?.validFrom, current.valid_from) || windowFieldChanges(requested?.validTo, current.valid_to);
+}
+function windowAfterUpsertCreate(requested) {
+  return { valid_from: requested.validFrom, valid_to: requested.validTo };
+}
+function windowAfterUpsertUpdate(current, requested) {
+  return {
+    valid_from: current.valid_from,
+    valid_to: requested.validTo ?? current.valid_to
+  };
+}
+function shouldCoalesceUpsert(existing, options, runDirtyCheck) {
+  const windowChanges = upsertWindowChanges(options, existing);
+  if (runDirtyCheck === void 0 || existing.deleted_at !== void 0 || windowChanges) {
+    return false;
+  }
+  try {
+    return runDirtyCheck().unchanged;
+  } catch {
+    return false;
+  }
+}
+
 // src/store/collections/edge-collection.ts
 function narrowEdge(edge) {
   return edge;
@@ -13449,13 +13988,29 @@ function buildCreateEdgeInput(kind, from, to, props, options) {
   if (options?.validTo !== void 0) input.validTo = options.validTo;
   return input;
 }
-function buildUpdateEdgeInput(id, props, options) {
-  const input = { id, props };
+function buildUpdateEdgeInput(kind, id, props, options) {
+  const input = { id, identity: { kind }, props };
+  if (options?.validTo !== void 0) input.validTo = options.validTo;
+  return input;
+}
+function buildUpsertUpdateEdgeInput(kind, id, from, to, props, options) {
+  const input = {
+    id,
+    identity: {
+      kind,
+      fromKind: from.kind,
+      fromId: from.id,
+      toKind: to.kind,
+      toId: to.id
+    },
+    props
+  };
+  if (options?.validFrom !== void 0) input.validFrom = options.validFrom;
   if (options?.validTo !== void 0) input.validTo = options.validTo;
   return input;
 }
 function endpointKey(endpointKind, id) {
-  return `${endpointKind}\0${id}`;
+  return encodeTupleKey([endpointKind, id]);
 }
 function groupEndpointIdsByKind(references) {
   const referencesByKind = groupBy(references, (ref) => ref.kind);
@@ -13502,6 +14057,7 @@ function createEdgeCollection(config) {
     executeUpdate: executeEdgeUpdate2,
     executeUpsertUpdate: executeEdgeUpsertUpdate2,
     executeDelete: executeEdgeDelete2,
+    executeDeleteBatch: executeEdgeDeleteBatch2,
     executeHardDelete: executeEdgeHardDelete2,
     temporalRowMatcher
   } = config;
@@ -13610,7 +14166,7 @@ function createEdgeCollection(config) {
     },
     async update(id, props, options) {
       const result = await executeEdgeUpdate2(
-        buildUpdateEdgeInput(id, props, options),
+        buildUpdateEdgeInput(kind, id, props, options),
         backend
       );
       return narrowEdge(result);
@@ -13650,10 +14206,10 @@ function createEdgeCollection(config) {
       };
     },
     async delete(id) {
-      await executeEdgeDelete2(id, backend);
+      await executeEdgeDelete2(kind, id, backend);
     },
     async hardDelete(id) {
-      await executeEdgeHardDelete2(id, backend);
+      await executeEdgeHardDelete2(kind, id, backend);
     },
     async find(filter, temporal) {
       const untypedFilter = filter;
@@ -13712,6 +14268,20 @@ function createEdgeCollection(config) {
         const toUpdate = [];
         const pending = /* @__PURE__ */ new Map();
         const deferred = [];
+        const repeatedIds = config.upsertDirtyCheck === void 0 ? /* @__PURE__ */ new Set() : findRepeatedUpsertIds(items);
+        function runDirtyCheck(edgeKind, id, currentProps, inputProps) {
+          if (config.upsertDirtyCheck === void 0) return void 0;
+          try {
+            return config.upsertDirtyCheck(
+              edgeKind,
+              id,
+              currentProps,
+              inputProps
+            );
+          } catch {
+            return void 0;
+          }
+        }
         let itemIndex = 0;
         for (const item of items) {
           const pendingEntry = pending.get(item.id);
@@ -13728,25 +14298,48 @@ function createEdgeCollection(config) {
                 item
               )
             });
+            pending.set(item.id, {
+              identity: {
+                kind,
+                fromKind: item.from.kind,
+                fromId: item.from.id,
+                toKind: item.to.kind,
+                toId: item.to.id
+              },
+              props: repeatedIds.has(item.id) ? runDirtyCheck(kind, item.id, {}, inputProps)?.validatedProps : void 0,
+              window: windowAfterUpsertCreate(item),
+              sourceIndex: itemIndex
+            });
             itemIndex++;
             continue;
           }
           const deletedAt = pendingEntry === void 0 ? requireDefined(original).deleted_at : void 0;
-          let dirty;
-          if (config.upsertDirtyCheck !== void 0) {
-            const currentProps = pendingEntry?.props ?? rowPropsToObject(requireDefined(original).props);
-            try {
-              dirty = config.upsertDirtyCheck(
-                original?.kind ?? kind,
-                item.id,
-                currentProps,
-                inputProps
-              );
-            } catch {
-              dirty = void 0;
-            }
-          }
-          const coalesce = dirty?.unchanged === true && deletedAt === void 0 && item.validFrom === void 0 && item.validTo === void 0;
+          const expectedIdentity = {
+            kind,
+            fromKind: item.from.kind,
+            fromId: item.from.id,
+            toKind: item.to.kind,
+            toId: item.to.id
+          };
+          const actualIdentity = pendingEntry === void 0 ? edgeIdentityFromRow(requireDefined(original)) : pendingEntry.identity;
+          assertEdgeIdentityMatches(
+            item.id,
+            expectedIdentity,
+            actualIdentity,
+            "update"
+          );
+          const currentProps = pendingEntry === void 0 ? rowPropsToObject(requireDefined(original).props) : pendingEntry.props;
+          const dirty = currentProps === void 0 ? void 0 : runDirtyCheck(
+            original?.kind ?? kind,
+            item.id,
+            currentProps,
+            inputProps
+          );
+          const currentWindow = pendingEntry === void 0 ? {
+            valid_from: requireDefined(original).valid_from,
+            valid_to: requireDefined(original).valid_to
+          } : pendingEntry.window;
+          const coalesce = dirty?.unchanged === true && deletedAt === void 0 && !upsertWindowChanges(item, currentWindow);
           if (coalesce) {
             if (pendingEntry === void 0) {
               results2[itemIndex] = narrowEdge(
@@ -13761,15 +14354,25 @@ function createEdgeCollection(config) {
           } else {
             toUpdate.push({
               index: itemIndex,
-              input: buildUpdateEdgeInput(item.id, inputProps, item),
+              input: buildUpsertUpdateEdgeInput(
+                kind,
+                item.id,
+                item.from,
+                item.to,
+                inputProps,
+                item
+              ),
               clearDeleted: deletedAt !== void 0
             });
-            if (dirty !== void 0) {
-              pending.set(item.id, {
-                props: dirty.validatedProps,
-                sourceIndex: itemIndex
-              });
-            }
+            pending.set(item.id, {
+              identity: actualIdentity,
+              props: dirty?.validatedProps,
+              // A resurrection rewrites both bounds only when it NAMES the lower
+              // one (buildUpdateEdge's clearDeleted leg); omitting `validFrom`
+              // keeps the stored window, exactly like a live-row update.
+              window: deletedAt !== void 0 && item.validFrom !== void 0 ? windowAfterUpsertCreate(item) : windowAfterUpsertUpdate(currentWindow, item),
+              sourceIndex: itemIndex
+            });
           }
           itemIndex++;
         }
@@ -13793,7 +14396,10 @@ function createEdgeCollection(config) {
         }
         return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
-      const { results, mutations } = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
+      const { results, mutations } = await runOptionallyInTransaction(
+        backend,
+        (target) => upsertAll(target)
+      );
       await config.maybeRefreshStatisticsAfterBulk?.(mutations);
       return results;
     },
@@ -13811,16 +14417,7 @@ function createEdgeCollection(config) {
     },
     async bulkDelete(ids) {
       if (ids.length === 0) return;
-      const deleteAll = async (target) => {
-        for (const id of ids) {
-          await executeEdgeDelete2(id, target);
-        }
-      };
-      if (backend.capabilities.transactions && "transaction" in backend) {
-        await backend.transaction(async (txBackend) => deleteAll(txBackend));
-        return;
-      }
-      await deleteAll(backend);
+      await executeEdgeDeleteBatch2(kind, ids, backend);
     },
     async findByEndpoints(from, to, options, temporal) {
       const result = await config.executeFindByEndpoints(
@@ -13900,18 +14497,6 @@ function createEdgeCollection(config) {
   };
 }
 
-// src/store/collections/coalesce.ts
-function shouldCoalesceUpsert(existing, options, runDirtyCheck) {
-  if (runDirtyCheck === void 0 || existing.deleted_at !== void 0 || options?.validFrom !== void 0 || options?.validTo !== void 0) {
-    return false;
-  }
-  try {
-    return runDirtyCheck().unchanged;
-  } catch {
-    return false;
-  }
-}
-
 // src/store/collections/node-collection.ts
 function narrowNode(node) {
   return node;
@@ -13937,7 +14522,6 @@ function evaluateNodePredicate(accessor, predicate) {
     {
       get(_target, property) {
         if (typeof property === "symbol") return;
-        if (property === "then" || property === "toJSON") return;
         if (property === "id" || property === "kind" || property === "$fulltext") {
           return accessor[property];
         }
@@ -13960,6 +14544,12 @@ function buildUpdateInput(kind, id, props, options) {
   if (options?.validTo !== void 0) input.validTo = options.validTo;
   return input;
 }
+function buildUpsertUpdateInput(kind, id, props, options) {
+  const input = { kind, id, props };
+  if (options?.validFrom !== void 0) input.validFrom = options.validFrom;
+  if (options?.validTo !== void 0) input.validTo = options.validTo;
+  return input;
+}
 function mapBulkNodeInputs(kind, items) {
   return items.map((item) => buildCreateInput(kind, item.props, item));
 }
@@ -13977,6 +14567,7 @@ function createNodeCollection(config) {
     executeUpdateWhere: executeNodeUpdateWhere2,
     executeUpsertUpdate: executeNodeUpsertUpdate2,
     executeDelete: executeNodeDelete2,
+    executeDeleteBatch: executeNodeDeleteBatch2,
     executeHardDelete: executeNodeHardDelete2,
     temporalRowMatcher,
     createQuery,
@@ -14147,20 +14738,30 @@ function createNodeCollection(config) {
     },
     async upsertByIdFromRecord(id, data, options) {
       const existing = await backend.getNode(graphId, kind, id);
-      if (existing) {
+      const coalesces = (row) => {
         const runDirtyCheck = config.upsertDirtyCheck && (() => requireDefined(config.upsertDirtyCheck)(
           kind,
           id,
-          rowPropsToObject(existing.props),
+          rowPropsToObject(row.props),
           data
         ));
-        if (shouldCoalesceUpsert(existing, options, runDirtyCheck)) {
-          return narrowNode(rowToNode2(existing));
+        return shouldCoalesceUpsert(row, options, runDirtyCheck);
+      };
+      const decision = existing !== void 0 && coalesces(existing) ? await runOptionallyInTransaction(
+        backend,
+        async (target) => {
+          const confirmed = await target.getNode(graphId, kind, id);
+          return confirmed !== void 0 && coalesces(confirmed) ? { verdict: "skip", row: confirmed } : { verdict: "write", row: confirmed };
         }
+      ) : { verdict: "write", row: existing };
+      if (decision.verdict === "skip") {
+        return narrowNode(rowToNode2(decision.row));
+      }
+      if (decision.row !== void 0) {
         const result2 = await executeNodeUpdate2(
-          buildUpdateInput(kind, id, data, options),
+          buildUpsertUpdateInput(kind, id, data, options),
           backend,
-          { clearDeleted: existing.deleted_at !== void 0 }
+          { clearDeleted: decision.row.deleted_at !== void 0 }
         );
         return narrowNode(result2);
       }
@@ -14206,6 +14807,15 @@ function createNodeCollection(config) {
         const toUpdate = [];
         const pending = /* @__PURE__ */ new Map();
         const deferred = [];
+        const repeatedIds = config.upsertDirtyCheck === void 0 ? /* @__PURE__ */ new Set() : findRepeatedUpsertIds(items);
+        function runDirtyCheck(id, currentProps, inputProps) {
+          if (config.upsertDirtyCheck === void 0) return void 0;
+          try {
+            return config.upsertDirtyCheck(kind, id, currentProps, inputProps);
+          } catch {
+            return void 0;
+          }
+        }
         let itemIndex = 0;
         for (const item of items) {
           const pendingEntry = pending.get(item.id);
@@ -14215,25 +14825,22 @@ function createNodeCollection(config) {
               index: itemIndex,
               input: buildCreateInput(kind, item.props, item)
             });
+            pending.set(item.id, {
+              props: repeatedIds.has(item.id) ? runDirtyCheck(item.id, {}, item.props)?.validatedProps : void 0,
+              window: windowAfterUpsertCreate(item),
+              sourceIndex: itemIndex
+            });
             itemIndex++;
             continue;
           }
           const deletedAt = pendingEntry === void 0 ? requireDefined(original).deleted_at : void 0;
-          let dirty;
-          if (config.upsertDirtyCheck !== void 0) {
-            const currentProps = pendingEntry?.props ?? rowPropsToObject(requireDefined(original).props);
-            try {
-              dirty = config.upsertDirtyCheck(
-                kind,
-                item.id,
-                currentProps,
-                item.props
-              );
-            } catch {
-              dirty = void 0;
-            }
-          }
-          const coalesce = dirty?.unchanged === true && deletedAt === void 0 && item.validFrom === void 0 && item.validTo === void 0;
+          const currentProps = pendingEntry === void 0 ? rowPropsToObject(requireDefined(original).props) : pendingEntry.props;
+          const dirty = currentProps === void 0 ? void 0 : runDirtyCheck(item.id, currentProps, item.props);
+          const currentWindow = pendingEntry === void 0 ? {
+            valid_from: requireDefined(original).valid_from,
+            valid_to: requireDefined(original).valid_to
+          } : pendingEntry.window;
+          const coalesce = dirty?.unchanged === true && deletedAt === void 0 && !upsertWindowChanges(item, currentWindow);
           if (coalesce) {
             if (pendingEntry === void 0) {
               results2[itemIndex] = narrowNode(
@@ -14248,15 +14855,17 @@ function createNodeCollection(config) {
           } else {
             toUpdate.push({
               index: itemIndex,
-              input: buildUpdateInput(kind, item.id, item.props, item),
+              input: buildUpsertUpdateInput(kind, item.id, item.props, item),
               clearDeleted: deletedAt !== void 0
             });
-            if (dirty !== void 0) {
-              pending.set(item.id, {
-                props: dirty.validatedProps,
-                sourceIndex: itemIndex
-              });
-            }
+            pending.set(item.id, {
+              props: dirty?.validatedProps,
+              // A resurrecting update rewrites BOTH bounds (buildUpdateNode's
+              // clearDeleted leg stamps `valid_from` and reopens `valid_to`);
+              // a live-row update moves only `valid_to`.
+              window: deletedAt === void 0 ? windowAfterUpsertUpdate(currentWindow, item) : windowAfterUpsertCreate(item),
+              sourceIndex: itemIndex
+            });
           }
           itemIndex++;
         }
@@ -14280,7 +14889,10 @@ function createNodeCollection(config) {
         }
         return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
-      const { results, mutations } = backend.capabilities.transactions && "transaction" in backend ? await backend.transaction(async (txBackend) => upsertAll(txBackend)) : await upsertAll(backend);
+      const { results, mutations } = await runOptionallyInTransaction(
+        backend,
+        (target) => upsertAll(target)
+      );
       await config.maybeRefreshStatisticsAfterBulk?.(mutations);
       return results;
     },
@@ -14298,16 +14910,7 @@ function createNodeCollection(config) {
     },
     async bulkDelete(ids) {
       if (ids.length === 0) return;
-      const deleteAll = async (target) => {
-        for (const id of ids) {
-          await executeNodeDelete2(kind, id, target);
-        }
-      };
-      if (backend.capabilities.transactions && "transaction" in backend) {
-        await backend.transaction(async (txBackend) => deleteAll(txBackend));
-        return;
-      }
-      await deleteAll(backend);
+      await executeNodeDeleteBatch2(kind, ids, backend);
     },
     async findByConstraint(constraintName, props) {
       const result = await executeFindByConstraint(
@@ -14505,6 +15108,7 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "insertNodesBatchReturning",
   "insertUnique",
   "insertUniqueBatch",
+  "probeContributions",
   "recordContributionMaterialization",
   "recordIndexMaterialization",
   "recordKindRemoval",
@@ -15415,7 +16019,7 @@ async function reconcilePendingRemovals(context) {
       const priorEntries = priorSchema[entity === "node" ? "nodes" : "edges"];
       const currentEntries = currentSchema[entity === "node" ? "nodes" : "edges"];
       for (const kindName of Object.keys(priorEntries)) {
-        if (kindName in currentEntries) continue;
+        if (hasOwnKey(currentEntries, kindName)) continue;
         if (recorded.has(kindRemovalKey(entity, kindName, currentRow.version))) {
           continue;
         }
@@ -15736,22 +16340,29 @@ function literal(value) {
 
 // src/store/operations/edge-operations.ts
 function getEdgeRegistration(graph, kind) {
+  if (!hasOwnKey(graph.edges, kind)) throw new KindNotFoundError(kind, "edge");
   const registration = graph.edges[kind];
   if (registration === void 0) throw new KindNotFoundError(kind, "edge");
   return registration;
 }
 function buildEdgeEndpointCacheKey(graphId, kind, id) {
-  return `${graphId}\0${kind}\0${id}`;
+  return encodeTupleKey([graphId, kind, id]);
 }
 function buildEdgeFromCacheKey(graphId, edgeKind, fromKind, fromId) {
-  return `${graphId}\0${edgeKind}\0${fromKind}\0${fromId}`;
+  return encodeTupleKey([graphId, edgeKind, fromKind, fromId]);
 }
 function buildEdgeBetweenCacheKey(graphId, edgeKind, fromKind, fromId, toKind, toId) {
-  return `${graphId}\0${edgeKind}\0${fromKind}\0${fromId}\0${toKind}\0${toId}`;
+  return encodeTupleKey([graphId, edgeKind, fromKind, fromId, toKind, toId]);
 }
 function buildCountEdgesFromCacheKey(params) {
   const activeOnly = params.activeOnly === true ? "1" : "0";
-  return `${params.graphId}\0${params.edgeKind}\0${params.fromKind}\0${params.fromId}\0${activeOnly}`;
+  return encodeTupleKey([
+    params.graphId,
+    params.edgeKind,
+    params.fromKind,
+    params.fromId,
+    activeOnly
+  ]);
 }
 function buildInsertEdgeParams(graphId, id, kind, fromKind, fromId, toKind, toId, props, validFrom, validTo) {
   const insertParams = {
@@ -15909,6 +16520,7 @@ async function validateAndPrepareEdgeCreate(ctx, input, id, backend) {
     "validFrom"
   );
   const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  assertOrderedValidityWindow(`edge "${id}"`, validFrom, validTo);
   const cardinality = registration.cardinality ?? "many";
   const constraintContext = {
     graphId: ctx.graphId,
@@ -15941,29 +16553,84 @@ async function validateAndPrepareEdgeCreate(ctx, input, id, backend) {
     )
   };
 }
+function edgeCardinality(ctx, kind) {
+  if (!hasOwnKey(ctx.graph.edges, kind)) return "many";
+  return getEdgeRegistration(ctx.graph, kind).cardinality ?? "many";
+}
+var EdgeConvergenceRaced = class extends Error {
+  constructor(kind) {
+    super(
+      `A competing writer claimed the ${kind} match key; re-resolving it. This is internal to getOrCreateByEndpoints and is never returned to a caller.`
+    );
+    this.name = "EdgeConvergenceRaced";
+  }
+};
 async function executeEdgeCreateInternal(ctx, input, backend, options) {
   const kind = input.kind;
   const id = input.id ?? generateId();
   const opContext = ctx.createOperationContext("create", "edge", kind, id);
-  return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
-    const prepared = await validateAndPrepareEdgeCreate(ctx, input, id, target);
-    let row;
+  const shouldReturnRow = options?.returnRow ?? true;
+  const convergeOn = options?.convergeOn;
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    async (target) => {
+      if (convergeOn !== void 0) {
+        const candidateRows = await target.findEdgesByKind({
+          graphId: ctx.graphId,
+          kind,
+          fromKind: input.fromKind,
+          fromId: input.fromId,
+          toKind: input.toKind,
+          toId: input.toId,
+          excludeDeleted: false,
+          temporalMode: "includeTombstones"
+        });
+        const { liveRow, deletedRow } = findMatchingEdge(
+          candidateRows,
+          convergeOn.matchOn,
+          convergeOn.props
+        );
+        if (liveRow !== void 0 || deletedRow !== void 0) {
+          throw new EdgeConvergenceRaced(kind);
+        }
+      }
+      const prepared = await validateAndPrepareEdgeCreate(
+        ctx,
+        input,
+        id,
+        target
+      );
+      const row = await withAlreadyExistsTranslation("edge", async () => {
+        if (shouldReturnRow) return target.insertEdge(prepared.insertParams);
+        await runInsertNoReturn(
+          edgeInsertDispatch(target),
+          prepared.insertParams
+        );
+        return;
+      });
+      return row === void 0 ? void 0 : rowToEdge(row);
+    },
     {
-      row = await target.insertEdge(prepared.insertParams);
+      // A create that runs a cardinality probe, or one converging on a match
+      // key, decides something the write must not have invalidated. A plain
+      // `many` create decides nothing and takes no lock.
+      fencesConstraintProbe: convergeOn === void 0 ? edgeWriteNeedsConstraintFence(edgeCardinality(ctx, kind)) : "edgeMatchKeyConvergence"
     }
-    if (row === void 0) return;
-    return rowToEdge(row);
-  });
+  );
 }
 async function executeEdgeCreate(ctx, input, backend) {
-  const result = await executeEdgeCreateInternal(ctx, input, backend);
-  if (!result) {
+  const edge = await executeEdgeCreateInternal(ctx, input, backend, {
+    returnRow: true
+  });
+  if (!edge) {
     throw new DatabaseOperationError(
       "Edge create failed: expected created edge row",
       { operation: "insert", entity: "edge" }
     );
   }
-  return result;
+  return edge;
 }
 async function primeEdgeBatchValidationCache(ctx, inputs, backend, seedEndpointRow) {
   if (backend.getNodes === void 0) return;
@@ -16017,31 +16684,53 @@ async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return;
   }
-  await runInWriteTransaction(ctx, backend, async (target) => {
-    const { batchInsertParams } = await prepareEdgeBatchCreates(
-      ctx,
-      inputs,
-      target
-    );
-    await runInsertBatch(edgeInsertDispatch(target), batchInsertParams);
-  });
+  await runInWriteTransaction(
+    ctx,
+    backend,
+    async (target) => {
+      const { batchInsertParams } = await prepareEdgeBatchCreates(
+        ctx,
+        inputs,
+        target
+      );
+      await withAlreadyExistsTranslation(
+        "edge",
+        () => runInsertBatch(edgeInsertDispatch(target), batchInsertParams)
+      );
+    },
+    { fencesConstraintProbe: batchFencesConstraintProbe(ctx, inputs) }
+  );
 }
 async function executeEdgeCreateBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return [];
   }
-  return runInWriteTransaction(ctx, backend, async (target) => {
-    const { batchInsertParams } = await prepareEdgeBatchCreates(
-      ctx,
-      inputs,
-      target
-    );
-    const rows = await runInsertBatchReturning(
-      edgeInsertDispatch(target),
-      batchInsertParams
+  return runInWriteTransaction(
+    ctx,
+    backend,
+    async (target) => {
+      const { batchInsertParams } = await prepareEdgeBatchCreates(
+        ctx,
+        inputs,
+        target
+      );
+      const rows = await withAlreadyExistsTranslation(
+        "edge",
+        () => runInsertBatchReturning(edgeInsertDispatch(target), batchInsertParams)
+      );
+      return rows.map((row) => rowToEdge(row));
+    },
+    { fencesConstraintProbe: batchFencesConstraintProbe(ctx, inputs) }
+  );
+}
+function batchFencesConstraintProbe(ctx, inputs) {
+  for (const input of inputs) {
+    const reason = edgeWriteNeedsConstraintFence(
+      edgeCardinality(ctx, input.kind)
     );
-    return rows.map((row) => rowToEdge(row));
-  });
+    if (reason !== void 0) return reason;
+  }
+  return void 0;
 }
 function computeEdgeUpdate(ctx, kind, id, existingProps, inputProps) {
   const registration = getEdgeRegistration(ctx.graph, kind);
@@ -16079,65 +16768,234 @@ async function performEdgeUpdate(ctx, input, target, options) {
   const id = input.id;
   const existing = await target.getEdge(ctx.graphId, id);
   if (!existing || !options?.clearDeleted && existing.deleted_at) {
-    throw new EdgeNotFoundError("unknown", id);
+    throw new EdgeNotFoundError(input.identity.kind, id);
   }
+  assertEdgeIdentityMatches(
+    id,
+    input.identity,
+    edgeIdentityFromRow(existing),
+    "update"
+  );
   const { validatedProps } = resolveEdgeUpdateProps(ctx, existing, input.props);
+  const validFrom = validateOptionalCanonicalIsoDate(
+    input.validFrom,
+    "validFrom"
+  );
   const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  const windowVerdict = assertWritableValidityWindow(
+    `edge "${id}"`,
+    validFrom,
+    {
+      effectiveValidFrom: existing.valid_from,
+      appliesStatedValidFrom: options?.clearDeleted === true,
+      // Unlike the node side, an edge RETAINS `valid_from` through a
+      // resurrection that does not name a new one, so the effective bound is the
+      // row's stored one on BOTH legs and there is no carve-out to make.
+      effectiveBoundIsStored: true
+    },
+    validTo
+  );
   const updateParams = {
     graphId: ctx.graphId,
     id,
-    props: validatedProps
+    kind: input.identity.kind,
+    props: validatedProps,
+    // The bound the window verdict above READ, carried into the same `WHERE` as
+    // the identity components and on exactly the same terms: present only when
+    // the verdict consulted it, because a component the caller made no claim
+    // about must not become a predicate that refuses legitimate writes.
+    ...windowVerdict.storedLowerBoundFence
   };
+  if (input.identity.fromKind !== void 0) {
+    updateParams.fromKind = input.identity.fromKind;
+  }
+  if (input.identity.fromId !== void 0) {
+    updateParams.fromId = input.identity.fromId;
+  }
+  if (input.identity.toKind !== void 0) {
+    updateParams.toKind = input.identity.toKind;
+  }
+  if (input.identity.toId !== void 0) {
+    updateParams.toId = input.identity.toId;
+  }
+  if (validFrom !== void 0) updateParams.validFrom = validFrom;
   if (validTo !== void 0) updateParams.validTo = validTo;
   if (options?.clearDeleted) updateParams.clearDeleted = true;
-  const row = await target.updateEdge(updateParams);
+  const row = await withUnmatchedEdgeUpdateRefusal(
+    ctx,
+    target,
+    id,
+    input.identity,
+    updateParams.expectedValidFrom !== void 0,
+    () => target.updateEdge(updateParams)
+  );
   return rowToEdge(row);
 }
+function isEdgeUpdateNoRowError(error) {
+  return error instanceof DatabaseOperationError && error.details.operation === "update" && error.details.entity === "edge" && error.details.reason === "no_row_returned";
+}
+async function withUnmatchedEdgeUpdateRefusal(ctx, target, id, expected, assertedValidFrom, write) {
+  try {
+    return await write();
+  } catch (error) {
+    if (!isEdgeUpdateNoRowError(error)) throw error;
+    const current = await target.getEdge(ctx.graphId, id);
+    if (current !== void 0) {
+      assertEdgeIdentityMatches(
+        id,
+        expected,
+        edgeIdentityFromRow(current),
+        "update"
+      );
+      if (assertedValidFrom && current.deleted_at === void 0) {
+        throw new EdgeUpdateTargetMoved(expected.kind, id);
+      }
+    }
+    throw new EdgeNotFoundError(expected.kind, id);
+  }
+}
+var EdgeUpdateTargetMoved = class extends Error {
+  constructor(kind, id) {
+    super(
+      `The ${kind} edge "${id}" was replaced between this update's read and its write; re-resolving it. This is internal and is never returned to a caller.`
+    );
+    this.name = "EdgeUpdateTargetMoved";
+  }
+};
+var EDGE_UPDATE_ATTEMPTS = 2;
+async function performEdgeUpdateConverging(ctx, input, target, options) {
+  for (let attempt = 1; attempt <= EDGE_UPDATE_ATTEMPTS; attempt += 1) {
+    try {
+      return await performEdgeUpdate(ctx, input, target, options);
+    } catch (error) {
+      if (!(error instanceof EdgeUpdateTargetMoved)) throw error;
+      if (attempt === EDGE_UPDATE_ATTEMPTS) {
+        throw new DatabaseOperationError(
+          `Edge update for "${input.id}" could not be applied to a stable row after ${EDGE_UPDATE_ATTEMPTS} attempts: the row was replaced between each read and its write. A concurrent writer is replacing this edge faster than it can be read; serialize the writers, or retry.`,
+          { operation: "update", entity: "edge" },
+          { cause: error }
+        );
+      }
+    }
+  }
+  throw new EdgeNotFoundError(input.identity.kind, input.id);
+}
 async function executeEdgeUpdate(ctx, input, backend) {
   const id = input.id;
   const gate = await backend.getEdge(ctx.graphId, id);
   if (!gate || gate.deleted_at) {
-    throw new EdgeNotFoundError("unknown", id);
+    throw new EdgeNotFoundError(input.identity.kind, id);
   }
+  assertEdgeIdentityMatches(
+    id,
+    input.identity,
+    edgeIdentityFromRow(gate),
+    "update"
+  );
   const opContext = ctx.createOperationContext("update", "edge", gate.kind, id);
   return runHookedWriteOperation(
     ctx,
     opContext,
     backend,
-    (target) => performEdgeUpdate(ctx, input, target)
+    (target) => performEdgeUpdateConverging(ctx, input, target)
   );
 }
 async function executeEdgeUpsertUpdate(ctx, input, backend, options) {
+  const resurrectCardinality = options?.resurrectCardinality;
   return runInWriteTransaction(
     ctx,
     backend,
-    (target) => performEdgeUpdate(ctx, input, target, options)
+    async (target) => {
+      if (resurrectCardinality !== void 0) {
+        await checkCardinalityConstraint(
+          {
+            graphId: ctx.graphId,
+            registry: ctx.registry,
+            backend: target
+          },
+          input.identity.kind,
+          resurrectCardinality.cardinality,
+          resurrectCardinality.fromKind,
+          resurrectCardinality.fromId,
+          resurrectCardinality.toKind,
+          resurrectCardinality.toId,
+          resurrectCardinality.effectiveValidTo
+        );
+      }
+      return performEdgeUpdateConverging(ctx, input, target, options);
+    },
+    {
+      // An in-place props update re-derives no constraint verdict: endpoints
+      // are immutable, so cardinality cannot change under it.
+      fencesConstraintProbe: resurrectCardinality === void 0 ? void 0 : edgeWriteNeedsConstraintFence(resurrectCardinality.cardinality)
+    }
   );
 }
-async function executeEdgeDelete(ctx, id, backend) {
+async function executeEdgeDelete(ctx, expectedKind, id, backend) {
   const gate = await backend.getEdge(ctx.graphId, id);
-  if (!gate || gate.deleted_at) return;
+  if (!gate) return;
+  assertEdgeIdentityMatches(
+    id,
+    { kind: expectedKind },
+    edgeIdentityFromRow(gate),
+    "delete"
+  );
+  if (gate.deleted_at) return;
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
   return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
     await target.deleteEdge({
       graphId: ctx.graphId,
-      id
+      id,
+      kind: expectedKind
     });
   });
 }
-async function executeEdgeHardDelete(ctx, id, backend) {
+async function executeEdgeDeleteBatch(ctx, expectedKind, ids, backend) {
+  await runInWriteTransaction(
+    ctx,
+    backend,
+    async (target) => {
+      let affectedCount = 0;
+      for (const id of ids) {
+        const current = await target.getEdge(ctx.graphId, id);
+        if (!current) continue;
+        assertEdgeIdentityMatches(
+          id,
+          { kind: expectedKind },
+          edgeIdentityFromRow(current),
+          "delete"
+        );
+        if (current.deleted_at) continue;
+        await target.deleteEdge({
+          graphId: ctx.graphId,
+          id,
+          kind: expectedKind
+        });
+        affectedCount += 1;
+      }
+      return affectedCount;
+    },
+    { didWrite: (affectedCount) => affectedCount > 0 }
+  );
+}
+async function executeEdgeHardDelete(ctx, expectedKind, id, backend) {
   const gate = await backend.getEdge(ctx.graphId, id);
   if (!gate) return;
+  assertEdgeIdentityMatches(
+    id,
+    { kind: expectedKind },
+    edgeIdentityFromRow(gate),
+    "hardDelete"
+  );
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
   return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
     await target.hardDeleteEdge({
       graphId: ctx.graphId,
-      id
+      id,
+      kind: expectedKind
     });
   });
 }
-var RECORD_SEP = "";
-var UNIT_SEP = "";
 var UNDEFINED_SENTINEL = "";
 function validateMatchOnFields(schema, matchOn, edgeKind) {
   if (matchOn.length === 0) return;
@@ -16155,7 +17013,7 @@ function validateMatchOnFields(schema, matchOn, edgeKind) {
       }
     );
   }
-  const invalidFields = matchOn.filter((field2) => !(field2 in shape));
+  const invalidFields = matchOn.filter((field2) => !hasOwnKey(shape, field2));
   if (invalidFields.length > 0) {
     throw new ValidationError(
       `Invalid matchOn fields for edge kind "${edgeKind}": ${invalidFields.join(", ")}`,
@@ -16183,16 +17041,20 @@ function stableStringify(value) {
   return `{${entries.join(",")}}`;
 }
 function buildEdgeCompositeKey(fromKind, fromId, toKind, toId, props, matchOn) {
-  const endpointPart = `${fromKind}${RECORD_SEP}${fromId}${RECORD_SEP}${toKind}${RECORD_SEP}${toId}`;
-  if (matchOn.length === 0) return endpointPart;
   const sortedFields = [...matchOn].toSorted();
-  const propertyParts = sortedFields.map(
-    (field2) => `${RECORD_SEP}${field2}${UNIT_SEP}${stableStringify(props[field2])}`
-  );
-  return endpointPart + propertyParts.join("");
+  return encodeTupleKey([
+    fromKind,
+    fromId,
+    toKind,
+    toId,
+    ...sortedFields.flatMap((field2) => [
+      field2,
+      stableStringify(readOwnProperty(props, field2))
+    ])
+  ]);
 }
 function buildEndpointPairKey(fromKind, fromId, toKind, toId) {
-  return `${fromKind}${RECORD_SEP}${fromId}${RECORD_SEP}${toKind}${RECORD_SEP}${toId}`;
+  return encodeTupleKey([fromKind, fromId, toKind, toId]);
 }
 function findMatchingEdge(rows, matchOn, inputProps) {
   let liveRow;
@@ -16201,7 +17063,7 @@ function findMatchingEdge(rows, matchOn, inputProps) {
     if (matchOn.length > 0) {
       const rowProps = rowPropsToObject(row.props);
       const matches = matchOn.every(
-        (field2) => stableStringify(rowProps[field2]) === stableStringify(inputProps[field2])
+        (field2) => stableStringify(readOwnProperty(rowProps, field2)) === stableStringify(readOwnProperty(inputProps, field2))
       );
       if (!matches) continue;
     }
@@ -16255,6 +17117,11 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
     "validFrom"
   );
   const validTo = validateOptionalCanonicalIsoDate(options?.validTo, "validTo");
+  assertOrderedValidityWindow(
+    `${kind} edge between ${fromKind} "${fromId}" and ${toKind} "${toId}"`,
+    validFrom,
+    validTo
+  );
   if (ifExists === "return") {
     const probeRows = await backend.findEdgesByKind({
       graphId: ctx.graphId,
@@ -16302,8 +17169,17 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
         ...validFrom !== void 0 && { validFrom },
         ...validTo !== void 0 && { validTo }
       };
-      const edge2 = await executeEdgeCreate(ctx, input, backend);
-      return { edge: edge2, action: "created" };
+      const created = await executeEdgeCreateInternal(ctx, input, backend, {
+        returnRow: true,
+        convergeOn: { matchOn, props: validatedProps }
+      });
+      if (created === void 0) {
+        throw new DatabaseOperationError(
+          "Edge create failed: expected created edge row",
+          { operation: "insert", entity: "edge" }
+        );
+      }
+      return { edge: created, action: "created" };
     }
     if (liveRow !== void 0) {
       if (ifExists === "return") {
@@ -16313,7 +17189,9 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
         ctx,
         {
           id: liveRow.id,
+          identity: { kind, fromKind, fromId, toKind, toId },
           props: validatedProps,
+          ...validFrom !== void 0 && { validFrom },
           ...validTo !== void 0 && { validTo }
         },
         backend
@@ -16326,39 +17204,50 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
     }
     const matchedDeletedRow = deletedRow;
     const effectiveValidTo = validTo ?? matchedDeletedRow.valid_to;
-    const constraintContext = {
-      graphId: ctx.graphId,
-      registry: ctx.registry,
-      backend
-    };
-    await checkCardinalityConstraint(
-      constraintContext,
-      kind,
-      cardinality,
-      fromKind,
-      fromId,
-      toKind,
-      toId,
-      effectiveValidTo
-    );
     const edge = await executeEdgeUpsertUpdate(
       ctx,
       {
         id: matchedDeletedRow.id,
+        identity: { kind, fromKind, fromId, toKind, toId },
         props: validatedProps,
+        ...validFrom !== void 0 && { validFrom },
         ...validTo !== void 0 && { validTo }
       },
       backend,
-      { clearDeleted: true }
+      {
+        clearDeleted: true,
+        resurrectCardinality: {
+          cardinality,
+          fromKind,
+          fromId,
+          toKind,
+          toId,
+          effectiveValidTo
+        }
+      }
     );
     return { edge, action: "resurrected" };
   }
-  try {
-    return await attempt();
-  } catch (error) {
-    if (!(error instanceof CardinalityError)) throw error;
-    return attempt();
+  const ATTEMPT_LIMIT = 3;
+  for (let remaining = ATTEMPT_LIMIT; remaining > 0; remaining -= 1) {
+    try {
+      return await attempt();
+    } catch (error) {
+      const retryable = error instanceof CardinalityError || error instanceof EdgeConvergenceRaced;
+      if (!retryable || remaining === 1) {
+        if (!(error instanceof EdgeConvergenceRaced)) throw error;
+        throw new DatabaseOperationError(
+          `getOrCreateByEndpoints for ${kind} between ${fromKind} "${fromId}" and ${toKind} "${toId}" lost its match key to a competing writer ${String(ATTEMPT_LIMIT)} times without converging. A concurrent writer is repeatedly creating and removing this edge; serialize those callers or retry the operation.`,
+          { operation: "insert", entity: "edge" },
+          { cause: error }
+        );
+      }
+    }
   }
+  throw new DatabaseOperationError(
+    "getOrCreateByEndpoints convergence loop exited without a verdict",
+    { operation: "insert", entity: "edge" }
+  );
 }
 async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend, options) {
   if (items.length === 0) return [];
@@ -16379,6 +17268,11 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       "validFrom"
     );
     const validTo = validateOptionalCanonicalIsoDate(item.validTo, "validTo");
+    assertOrderedValidityWindow(
+      `${kind} edge between ${item.fromKind} "${item.fromId}" and ${item.toKind} "${item.toId}"`,
+      validFrom,
+      validTo
+    );
     const compositeKey = buildEdgeCompositeKey(
       item.fromKind,
       item.fromId,
@@ -16481,6 +17375,9 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
           fromId: entry2.fromId,
           toKind: entry2.toKind,
           toId: entry2.toId,
+          ...entry2.validFrom !== void 0 && {
+            validFrom: entry2.validFrom
+          },
           ...entry2.validTo !== void 0 && { validTo: entry2.validTo }
         });
       }
@@ -16504,75 +17401,108 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       return found;
     }
   }
-  return runInWriteTransaction(ctx, backend, async (target) => {
-    const { toCreate, toFetch, duplicateOf } = partitionEntries(
-      await fetchRowsByEndpoint(target)
-    );
-    const results = Array.from({ length: items.length });
-    if (toCreate.length > 0) {
-      const createInputs = toCreate.map((entry2) => entry2.input);
-      const createdEdges = await executeEdgeCreateBatch(
-        ctx,
-        createInputs,
-        target
-      );
-      for (const [batchIndex, entry2] of toCreate.entries()) {
-        results[entry2.index] = {
-          edge: requireDefined(createdEdges[batchIndex]),
-          action: "created"
-        };
-      }
-    }
-    for (const entry2 of toFetch) {
-      if (entry2.isDeleted) {
-        const effectiveValidTo = entry2.validTo ?? entry2.row.valid_to;
-        const constraintContext = {
-          graphId: ctx.graphId,
-          registry: ctx.registry,
-          backend: target
-        };
-        await checkCardinalityConstraint(
-          constraintContext,
-          kind,
-          cardinality,
-          entry2.fromKind,
-          entry2.fromId,
-          entry2.toKind,
-          entry2.toId,
-          effectiveValidTo
-        );
-        const edge = await executeEdgeUpsertUpdate(
-          ctx,
-          {
-            id: entry2.row.id,
-            props: entry2.validatedProps,
-            ...entry2.validTo !== void 0 && { validTo: entry2.validTo }
-          },
-          target,
-          { clearDeleted: true }
-        );
-        results[entry2.index] = { edge, action: "resurrected" };
-      } else if (ifExists === "update") {
-        const edge = await executeEdgeUpsertUpdate(
-          ctx,
-          {
-            id: entry2.row.id,
-            props: entry2.validatedProps,
-            ...entry2.validTo !== void 0 && { validTo: entry2.validTo }
-          },
-          target
+  function runBatch() {
+    return runInWriteTransaction(
+      ctx,
+      backend,
+      async (target) => {
+        const { toCreate, toFetch, duplicateOf } = partitionEntries(
+          await fetchRowsByEndpoint(target)
         );
-        results[entry2.index] = { edge, action: "updated" };
-      } else {
-        results[entry2.index] = { edge: rowToEdge(entry2.row), action: "found" };
-      }
-    }
-    for (const { index, sourceIndex } of duplicateOf) {
-      const sourceResult = requireDefined(results[sourceIndex]);
-      results[index] = { edge: sourceResult.edge, action: "found" };
-    }
-    return results;
-  });
+        const results = Array.from({ length: items.length });
+        if (toCreate.length > 0) {
+          const createInputs = toCreate.map((entry2) => entry2.input);
+          const createdEdges = await executeEdgeCreateBatch(
+            ctx,
+            createInputs,
+            target
+          );
+          for (const [batchIndex, entry2] of toCreate.entries()) {
+            results[entry2.index] = {
+              edge: requireDefined(createdEdges[batchIndex]),
+              action: "created"
+            };
+          }
+        }
+        for (const entry2 of toFetch) {
+          if (entry2.isDeleted) {
+            const edge = await executeEdgeUpsertUpdate(
+              ctx,
+              {
+                id: entry2.row.id,
+                identity: {
+                  kind,
+                  fromKind: entry2.fromKind,
+                  fromId: entry2.fromId,
+                  toKind: entry2.toKind,
+                  toId: entry2.toId
+                },
+                props: entry2.validatedProps,
+                ...entry2.validFrom !== void 0 && {
+                  validFrom: entry2.validFrom
+                },
+                ...entry2.validTo !== void 0 && { validTo: entry2.validTo }
+              },
+              target,
+              {
+                clearDeleted: true,
+                resurrectCardinality: {
+                  cardinality,
+                  fromKind: entry2.fromKind,
+                  fromId: entry2.fromId,
+                  toKind: entry2.toKind,
+                  toId: entry2.toId,
+                  effectiveValidTo: entry2.validTo ?? entry2.row.valid_to
+                }
+              }
+            );
+            results[entry2.index] = { edge, action: "resurrected" };
+          } else if (ifExists === "update") {
+            const edge = await executeEdgeUpsertUpdate(
+              ctx,
+              {
+                id: entry2.row.id,
+                identity: {
+                  kind,
+                  fromKind: entry2.fromKind,
+                  fromId: entry2.fromId,
+                  toKind: entry2.toKind,
+                  toId: entry2.toId
+                },
+                props: entry2.validatedProps,
+                ...entry2.validFrom !== void 0 && {
+                  validFrom: entry2.validFrom
+                },
+                ...entry2.validTo !== void 0 && { validTo: entry2.validTo }
+              },
+              target
+            );
+            results[entry2.index] = { edge, action: "updated" };
+          } else {
+            results[entry2.index] = {
+              edge: rowToEdge(entry2.row),
+              action: "found"
+            };
+          }
+        }
+        for (const { index, sourceIndex } of duplicateOf) {
+          const sourceResult = requireDefined(results[sourceIndex]);
+          results[index] = { edge: sourceResult.edge, action: "found" };
+        }
+        return results;
+      },
+      // A bulk getOrCreate always converges on a match key no database key
+      // backs, whatever its cardinality — the same reason the single-item path
+      // fences unconditionally.
+      { fencesConstraintProbe: "edgeMatchKeyConvergence" }
+    );
+  }
+  try {
+    return await runBatch();
+  } catch (error) {
+    if (!(error instanceof CardinalityError)) throw error;
+    return runBatch();
+  }
 }
 
 // src/store/recorded-read-service.ts
@@ -16906,6 +17836,12 @@ function createTransactionReceiptRecorder() {
   const counters = {
     nodes: createCountBucket(),
     edges: createCountBucket(),
+    identity: {
+      sameAssertions: 0,
+      differentAssertions: 0,
+      retractions: 0,
+      total: 0
+    },
     total: 0
   };
   let sealed = false;
@@ -16918,15 +17854,17 @@ function createTransactionReceiptRecorder() {
       increment(counters.edges, kind, count2);
       counters.total += count2;
     },
+    recordIdentity(kind, count2) {
+      counters.identity[kind] += count2;
+      counters.identity.total += count2;
+      counters.total += count2;
+    },
     snapshot(recorded) {
       return Object.freeze({
         writes: Object.freeze({
-          nodes: Object.freeze(
-            Object.assign(createCountBucket(), counters.nodes)
-          ),
-          edges: Object.freeze(
-            Object.assign(createCountBucket(), counters.edges)
-          ),
+          nodes: Object.freeze({ ...counters.nodes }),
+          edges: Object.freeze({ ...counters.edges }),
+          identity: Object.freeze({ ...counters.identity }),
           total: counters.total
         }),
         ...recorded === void 0 ? {} : { recorded }
@@ -16948,6 +17886,67 @@ function createTransactionReceiptRecorder() {
     }
   };
 }
+function wrapTransactionIdentity(identity, recorder) {
+  return {
+    representativeOf: (ref) => identity.representativeOf(ref),
+    membersOf: (ref) => identity.membersOf(ref),
+    nodesOf: (ref) => identity.nodesOf(ref),
+    areSame: (a, b) => identity.areSame(a, b),
+    areDifferent: (a, b) => identity.areDifferent(a, b),
+    assertionsOf: (ref) => identity.assertionsOf(ref),
+    async assertSame(a, b) {
+      recorder.assertWritable();
+      const result = await identity.assertSame(a, b);
+      recorder.recordIdentity("sameAssertions", 1);
+      return result;
+    },
+    async assertDifferent(a, b) {
+      recorder.assertWritable();
+      const result = await identity.assertDifferent(a, b);
+      recorder.recordIdentity("differentAssertions", 1);
+      return result;
+    },
+    async bulkAssertSame(pairs) {
+      recorder.assertWritable();
+      const count2 = pairs.length;
+      const result = await identity.bulkAssertSame(pairs);
+      recorder.recordIdentity("sameAssertions", count2);
+      return result;
+    },
+    async bulkAssertDifferent(pairs) {
+      recorder.assertWritable();
+      const count2 = pairs.length;
+      const result = await identity.bulkAssertDifferent(pairs);
+      recorder.recordIdentity("differentAssertions", count2);
+      return result;
+    },
+    async retractAssertion(id) {
+      recorder.assertWritable();
+      const result = await identity.retractAssertion(id);
+      recorder.recordIdentity("retractions", 1);
+      return result;
+    },
+    async retractSameAssertion(a, b) {
+      recorder.assertWritable();
+      const result = await identity.retractSameAssertion(a, b);
+      recorder.recordIdentity("retractions", 1);
+      return result;
+    },
+    async retractDifferentAssertion(a, b) {
+      recorder.assertWritable();
+      const result = await identity.retractDifferentAssertion(a, b);
+      recorder.recordIdentity("retractions", 1);
+      return result;
+    },
+    async bulkRetractAssertions(ids) {
+      recorder.assertWritable();
+      const count2 = ids.length;
+      const result = await identity.bulkRetractAssertions(ids);
+      recorder.recordIdentity("retractions", count2);
+      return result;
+    }
+  };
+}
 function isWrappedMethod(value) {
   return typeof value === "function";
 }
@@ -17056,6 +18055,10 @@ var CAUGHT_UP_VERB_DETAILS = {
   repair: {
     phrase: "repair contributions for",
     code: "REPAIR_CONTRIBUTIONS_BEFORE_INITIALIZE"
+  },
+  rebuild: {
+    phrase: "rebuild a contribution for",
+    code: "REBUILD_CONTRIBUTION_BEFORE_INITIALIZE"
   }
 };
 var ROW_MAPPER_CONFIGS = {
@@ -17128,6 +18131,20 @@ async function commitEvolvedSchemaWhenRequiredKindsAreEmpty(backend, graph, curr
     }
   );
 }
+async function assertEvolvedSchemaRequiredKindsEmpty(backend, graphId, classification) {
+  const counts = await Promise.all(
+    classification.requireEmpty.map(async (entry2) => ({
+      entry: entry2,
+      count: entry2.entity === "node" ? await backend.countNodesByKind({ graphId, kind: entry2.kindName }) : await backend.countEdgesByKind({ graphId, kind: entry2.kindName })
+    }))
+  );
+  const nonEmpty = new Set(
+    counts.filter(({ count: count2 }) => count2 > 0).map(({ entry: entry2 }) => entry2)
+  );
+  const error = buildIncompatibleChangeError(classification, nonEmpty, graphId);
+  if (error !== void 0) throw error;
+}
+var IDENTITY_FACADES = /* @__PURE__ */ new WeakMap();
 var StoreImplementation = class _StoreImplementation {
   [STORE_RUNTIME];
   #graph;
@@ -17159,6 +18176,19 @@ var StoreImplementation = class _StoreImplementation {
   #search;
   constructor(graph, backend, options, schemaMetadata, adapterBackend) {
     this.#graph = graph;
+    if (graph.identity !== void 0 && (!backend.capabilities.transactions || backend.executeStatement === void 0)) {
+      throw new ConfigurationError(
+        "Operational Identity requires an atomic transactional backend with statement execution support.",
+        {
+          code: "IDENTITY_REQUIRES_ATOMIC_BACKEND",
+          transactions: backend.capabilities.transactions,
+          statementExecution: backend.executeStatement !== void 0
+        },
+        {
+          suggestion: "Use a transactional SQLite or PostgreSQL driver; Cloudflare D1 and neon-http cannot host identity closure maintenance."
+        }
+      );
+    }
     this.#baseBackend = asRawBackend(backend);
     this.#adapterBackend = adapterBackend;
     this.#captureEnabled = options?.history === true;
@@ -17207,7 +18237,56 @@ var StoreImplementation = class _StoreImplementation {
       recordedEdgeGetByIds: (kind, ids, coordinate) => this.recordedEdgeGetByIds(kind, ids, coordinate),
       recordedEdgeScan: (kind, coordinate, options2) => this.recordedEdgeScan(kind, coordinate, options2),
       subgraphAtCoordinate: (rootId, subgraphOptions) => this.subgraphAtCoordinate(rootId, subgraphOptions),
-      algorithmsAtCoordinate: (coordinate) => this.algorithmsAtCoordinate(coordinate)
+      algorithmsAtCoordinate: (coordinate) => this.algorithmsAtCoordinate(coordinate),
+      identityAtCoordinate: (coordinate) => this.identityAtCoordinate(coordinate),
+      rebuildIdentityClosure: () => this.rebuildIdentityClosure(),
+      validateIdentity: () => this.validateIdentity(),
+      liveNodesSharingIds: async (ids, target) => {
+        const backend2 = target ?? this.#baseBackend;
+        const liveKindsById = await liveNodeKindsSharingIds(
+          this.#identityContext(backend2),
+          backend2,
+          ids
+        );
+        const peers = [];
+        for (const [id, kinds] of liveKindsById) {
+          for (const kind of kinds) peers.push({ kind, id });
+        }
+        return peers;
+      },
+      identityAssertionRowsByIds: async (ids, target) => {
+        if (this.#graph.identity === void 0) return /* @__PURE__ */ new Map();
+        const backend2 = target ?? this.#baseBackend;
+        const ctx = this.#identityContext(backend2);
+        const rows = await loadAssertionsByIds(
+          backend2,
+          ctx.schema,
+          this.graphId,
+          ids
+        );
+        return new Map(
+          [...rows].map(([id, row]) => [id, toTransferAssertion(row)])
+        );
+      },
+      structuralIdentityClasses: async (references, target) => {
+        if (this.#graph.identity === void 0) return /* @__PURE__ */ new Map();
+        const backend2 = target ?? this.#baseBackend;
+        const ctx = this.#identityContext(backend2);
+        return loadCurrentStructuralClasses(
+          backend2,
+          ctx.schema,
+          this.graphId,
+          references
+        );
+      },
+      readCurrentIdentityAssertions: (mode, options2) => this.readCurrentIdentityAssertions(mode, options2),
+      identityAssertionsAtTarget: (target, mode) => this.identityAssertionsAtTarget(target, mode),
+      readIdentityAssertionPageAtTarget: (target, mode, options2) => this.readIdentityAssertionPageAtTarget(target, mode, options2),
+      lockIdentityImportTarget: (target) => this.lockIdentityImportTarget(target),
+      foldImportedIdentityNodes: (target, references) => this.foldImportedIdentityNodes(target, references),
+      importIdentityAssertionsAtTarget: (target, assertions, mode) => this.importIdentityAssertionsAtTarget(target, assertions, mode),
+      applyIdentityMergeAtTarget: (target, retractionIds, assertions) => this.applyIdentityMergeAtTarget(target, retractionIds, assertions),
+      assertIdentityClassesConsistentAtTarget: (target, seeds) => this.assertIdentityClassesConsistentAtTarget(target, seeds)
     };
     Object.defineProperty(this, STORE_RUNTIME, {
       configurable: false,
@@ -17232,6 +18311,215 @@ var StoreImplementation = class _StoreImplementation {
   get registry() {
     return this.#registry;
   }
+  /**
+   * The TypeGraph Identity Profile facade. Reachable through the public
+   * {@link Store} surface only on graphs that declared `identity: { ... }`;
+   * the runtime guard below catches widened or JavaScript callers.
+   *
+   * The facade is memoized per store, so it must not close over any state a
+   * lifecycle operation can move — see `#identityContext`.
+   */
+  get identity() {
+    this.#requireIdentityEnabled(
+      'Add identity: { sameIdAcrossKinds: "fold" } to defineGraph(...).'
+    );
+    const existing = IDENTITY_FACADES.get(this);
+    if (existing !== void 0) return existing;
+    const facade = createIdentityFacade(this.#identityContext(this.#backend));
+    IDENTITY_FACADES.set(this, facade);
+    return facade;
+  }
+  /**
+   * Refuses an identity operation on a graph that never declared
+   * `identity: { ... }`, where none of the identity tables exist.
+   */
+  #requireIdentityEnabled(suggestion) {
+    if (this.#graph.identity !== void 0) return;
+    throw new ConfigurationError(
+      "Identity is not enabled for this graph.",
+      { code: "IDENTITY_NOT_ENABLED", graphId: this.graphId },
+      suggestion === void 0 ? void 0 : { suggestion }
+    );
+  }
+  /** @internal Builds the identity read facade for a pinned StoreView. */
+  identityAtCoordinate(coordinate) {
+    this.#requireIdentityEnabled();
+    const recordedAsOf = coordinate.recorded?.asOf;
+    const backend = recordedAsOf === void 0 ? this.#backend : this.#recordedReads.backendForCoordinate(
+      coordinate,
+      "recorded-identity"
+    );
+    const schema = recordedReadSchemaFor(
+      this.#sqlSchema(),
+      recordedAsOf,
+      this.#recordedReadBinding,
+      "recorded-identity"
+    );
+    return createIdentityReadFacade({
+      ...this.#identityContext(backend),
+      schema,
+      coordinate
+    });
+  }
+  /** Rebuilds derived current identity closure without advancing revision. */
+  async rebuildIdentityClosure() {
+    this.#requireIdentityEnabled();
+    await runInWriteTransaction(
+      {
+        graphId: this.graphId,
+        schemaVersion: this.#schemaMetadata.schemaVersion,
+        historyEnabled: this.#captureEnabled,
+        revisionTrackingEnabled: this.#revisionTrackingEnabled,
+        revisionSchema: this.#sqlSchema()
+      },
+      this.#baseBackend,
+      async (target) => rebuildIdentityClosureForContext(this.#identityContext(target)),
+      { didWrite: () => false }
+    );
+  }
+  /**
+   * @internal Validates/rebuilds identity under schema-transition locks.
+   *
+   * `provisionDerivedRelations` carries the DDL `ensureIdentitySchemaStorage`
+   * deliberately did not run outside this transaction, so an evolution that
+   * fails leaves no half-published derived relation behind.
+   */
+  async identitySchemaPreflight(target, provisionDerivedRelations) {
+    await identitySchemaCommitPreflight(this.#identityContext(this.#backend), {
+      enablement: false,
+      provisionDerivedRelations
+    })(target);
+  }
+  /** @internal Read-only startup integrity verification. */
+  async validateIdentity() {
+    if (this.#graph.identity === void 0) return;
+    await validateIdentityForContext(this.#identityContext(this.#baseBackend));
+  }
+  /** @internal Cascades removed kinds in the schema-commit transaction. */
+  async removeIdentityKindsInSchemaPreflight(target, kinds, options) {
+    if (!this.#captureEnabled) {
+      await removeIdentityKindsForContext(
+        this.#identityContext(target),
+        kinds,
+        options
+      );
+      return;
+    }
+    const scope = createRecordedTransactionScope(
+      target,
+      this.#sqlSchema(),
+      target.dialect === "sqlite"
+    );
+    await removeIdentityKindsForContext(
+      this.#identityContext(scope.backend),
+      kinds,
+      options
+    );
+    await scope.flush();
+  }
+  /**
+   * @internal Reads the graph's identity assertions in transfer shape, honoring
+   * this store's SQL binding. Used by interchange export, base-version
+   * fingerprinting, and merge staging/diff.
+   */
+  readCurrentIdentityAssertions(mode, options) {
+    if (this.#graph.identity === void 0) return Promise.resolve([]);
+    return readIdentityAssertionsForInterchange(
+      this.#identityContext(this.#baseBackend),
+      mode,
+      options
+    );
+  }
+  /** @internal Reads identity truth through an already-bound transaction. */
+  identityAssertionsAtTarget(target, mode = "state") {
+    if (this.#graph.identity === void 0) return Promise.resolve([]);
+    return readIdentityAssertionsForInterchange(
+      this.#identityContext(target),
+      mode
+    );
+  }
+  /** @internal Reads one bounded identity-assertion page at a bound target. */
+  readIdentityAssertionPageAtTarget(target, mode, options) {
+    if (this.#graph.identity === void 0) {
+      return Promise.resolve({ assertions: [], done: true });
+    }
+    return readIdentityAssertionPageAtTarget(
+      this.#identityContext(target),
+      target,
+      mode,
+      options
+    );
+  }
+  /** @internal Acquires the enabled graph's identity lock for an import. */
+  lockIdentityImportTarget(target) {
+    return this.#graph.identity === void 0 ? Promise.resolve() : lockIdentityGraph(target, this.graphId);
+  }
+  /** @internal Restores same-id folding after the ops-layer import bypass. */
+  foldImportedIdentityNodes(target, references) {
+    if (this.#graph.identity === void 0 || references.length === 0) {
+      return Promise.resolve();
+    }
+    return foldIdentityForCreatedNodes(
+      {
+        graphId: this.graphId,
+        registry: this.#registry,
+        sameIdAcrossKinds: this.#graph.identity.sameIdAcrossKinds,
+        schema: this.#sqlSchema()
+      },
+      target,
+      references
+    );
+  }
+  /** @internal Applies identity interchange rows inside an import transaction. */
+  importIdentityAssertionsAtTarget(target, assertions, mode) {
+    if (assertions.length === 0) {
+      return Promise.resolve({ created: 0, skipped: 0 });
+    }
+    if (this.#graph.identity === void 0) {
+      throw new ConfigurationError(
+        "Cannot import identity assertions into an identity-disabled graph.",
+        { code: "IDENTITY_IMPORT_REQUIRES_PROFILE", graphId: this.graphId }
+      );
+    }
+    return importIdentityAssertionsIntoTarget(
+      this.#identityContext(target),
+      target,
+      assertions,
+      mode
+    );
+  }
+  /**
+   * @internal Post-write identity validation for a graph-merge commit: proves
+   * the identity classes the merge touched carry no contradiction in the state
+   * the merge just wrote, inside the merge's own transaction.
+   */
+  assertIdentityClassesConsistentAtTarget(target, seeds) {
+    if (this.#graph.identity === void 0 || seeds.length === 0) {
+      return Promise.resolve();
+    }
+    return assertAffectedIdentityClassesConsistent(
+      this.#identityContext(target),
+      target,
+      seeds
+    );
+  }
+  /** @internal Mechanical graph-merge apply through the mutation coordinator. */
+  applyIdentityMergeAtTarget(target, retractionIds, assertions) {
+    if (retractionIds.length === 0 && assertions.length === 0) {
+      return Promise.resolve({ created: 0, retracted: 0 });
+    }
+    if (this.#graph.identity === void 0) {
+      throw new ConfigurationError(
+        "Cannot apply identity merge changes to an identity-disabled graph.",
+        { code: "IDENTITY_MERGE_REQUIRES_PROFILE", graphId: this.graphId }
+      );
+    }
+    return applyIdentityChangesForContext(
+      this.#identityContext(target),
+      retractionIds,
+      assertions
+    );
+  }
   /**
    * An opaque, in-memory snapshot of this store's reconciled schema — the
    * merged compile-time + runtime-committed graph plus the committed version
@@ -17604,6 +18892,7 @@ var StoreImplementation = class _StoreImplementation {
         upsertDirtyCheck: (kind, id, existingProps, inputProps) => nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps)
       },
       executeDelete: (kind, id, backend) => executeNodeDelete(ctx, kind, id, backend),
+      executeDeleteBatch: (kind, ids, backend) => executeNodeDeleteBatch(ctx, kind, ids, backend),
       executeHardDelete: (kind, id, backend) => executeNodeHardDelete(ctx, kind, id, backend),
       temporalRowMatcher: (options) => this.#temporalRowMatcher(options),
       createQuery: () => this.query(),
@@ -17661,8 +18950,9 @@ var StoreImplementation = class _StoreImplementation {
       ...this.#options?.coalesceUnchangedUpserts === true && {
         upsertDirtyCheck: (kind, id, existingProps, inputProps) => edgeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps)
       },
-      executeDelete: (id, backend) => executeEdgeDelete(ctx, id, backend),
-      executeHardDelete: (id, backend) => executeEdgeHardDelete(ctx, id, backend),
+      executeDelete: (kind, id, backend) => executeEdgeDelete(ctx, kind, id, backend),
+      executeDeleteBatch: (kind, ids, backend) => executeEdgeDeleteBatch(ctx, kind, ids, backend),
+      executeHardDelete: (kind, id, backend) => executeEdgeHardDelete(ctx, kind, id, backend),
       temporalRowMatcher: (options) => this.#temporalRowMatcher(options),
       createQuery: () => this.query(),
       executeGetOrCreateByEndpoints: (kind, fromKind, fromId, toKind, toId, props, backend, options) => executeEdgeGetOrCreateByEndpoints(
@@ -18267,9 +19557,12 @@ var StoreImplementation = class _StoreImplementation {
           receiptRecorder
         ));
       }
+      const identity = this.#graph.identity === void 0 ? void 0 : createIdentityFacade(this.#identityContext(this.#backend));
+      const receiptIdentity = identity === void 0 || receiptRecorder === void 0 ? identity : wrapTransactionIdentity(identity, receiptRecorder);
       const fallbackContext = {
         nodes,
         edges,
+        ...receiptIdentity === void 0 ? {} : { identity: receiptIdentity },
         // No real transaction: `tx.sql` is absent and there is no atomicity.
         sqlAvailability: "unavailable",
         backend: createTransactionReadBackend(this.#backend),
@@ -18300,15 +19593,31 @@ var StoreImplementation = class _StoreImplementation {
       recordedByGraph = instants;
     }) : backendOptions;
     try {
-      const run = async (txBackend, nativeTransaction) => invoke(
-        this.#buildTransactionContext(
+      const run = async (txBackend, nativeTransaction) => {
+        const invokeTransaction = () => invoke(
+          this.#buildTransactionContext(
+            txBackend,
+            nativeTransaction,
+            runHooks,
+            receiptRecorder,
+            runBulkHooks
+          )
+        );
+        if (!this.#captureEnabled && !this.#revisionTrackingEnabled) {
+          return invokeTransaction();
+        }
+        return withWriteTransactionSession(
           txBackend,
-          nativeTransaction,
-          runHooks,
-          receiptRecorder,
-          runBulkHooks
-        )
-      );
+          {
+            graphId: this.graphId,
+            schemaVersion: this.#schemaMetadata.schemaVersion,
+            historyEnabled: this.#captureEnabled,
+            revisionTrackingEnabled: this.#revisionTrackingEnabled,
+            revisionSchema: this.#sqlSchema()
+          },
+          invokeTransaction
+        );
+      };
       const result = this.#captureEnabled || this.#adapterBackend === void 0 ? await this.#backend.transaction(
         (txBackend) => run(txBackend, void 0),
         transactionOptions
@@ -18494,10 +19803,15 @@ var StoreImplementation = class _StoreImplementation {
         context.edges,
         scopeRecorder
       );
+      const identity = this.#graph.identity === void 0 ? void 0 : wrapTransactionIdentity(
+        context.identity,
+        scopeRecorder
+      );
       const scoped = this.#attachMeasure(
         overlayPropertyDescriptors(context, {
           nodes,
           edges,
+          ...identity === void 0 ? {} : { identity },
           getNodeCollection: (kind) => this.#resolveDynamicNodeCollection(nodes, kind)
         })
       );
@@ -18551,10 +19865,13 @@ var StoreImplementation = class _StoreImplementation {
         receiptRecorder
       ));
     }
+    const identity = this.#graph.identity === void 0 ? void 0 : createIdentityFacade(this.#identityContext(txBackend));
+    const receiptIdentity = identity === void 0 || receiptRecorder === void 0 ? identity : wrapTransactionIdentity(identity, receiptRecorder);
     const getNodeCollection = (kind) => this.#resolveDynamicNodeCollection(nodes, kind);
     const base = {
       nodes,
       edges,
+      ...receiptIdentity === void 0 ? {} : { identity: receiptIdentity },
       backend: createTransactionReadBackend(txBackend),
       [TRANSACTION_RUNTIME]: { backend: txBackend, runNodeOperationHooks },
       getNodeCollection
@@ -18587,6 +19904,67 @@ var StoreImplementation = class _StoreImplementation {
     });
     return receiptRecorder === void 0 ? withSql : this.#attachMeasure(withSql);
   }
+  #identityContext(backend) {
+    const currentSchemaVersion = () => this.#schemaMetadata.schemaVersion;
+    return {
+      graph: this.#graph,
+      graphId: this.graphId,
+      get schemaVersion() {
+        return currentSchemaVersion();
+      },
+      registry: this.#registry,
+      backend,
+      schema: this.#sqlSchema(),
+      historyEnabled: this.#captureEnabled,
+      revisionTrackingEnabled: this.#revisionTrackingEnabled,
+      sameIdAcrossKinds: this.#graph.identity?.sameIdAcrossKinds ?? "ignore",
+      loadNodes: async (references, coordinate) => {
+        const idsByKind = /* @__PURE__ */ new Map();
+        for (const reference of references) {
+          const ids = idsByKind.get(reference.kind) ?? /* @__PURE__ */ new Set();
+          ids.add(reference.id);
+          idsByKind.set(reference.kind, ids);
+        }
+        const loadedByReference = /* @__PURE__ */ new Map();
+        await Promise.all(
+          [...idsByKind].map(async ([kind, idSet]) => {
+            const ids = [...idSet];
+            if (coordinate?.recorded !== void 0) {
+              const nodes = await this.recordedNodeGetByIds(
+                kind,
+                ids.map((id) => id),
+                coordinate
+              );
+              for (const [index, node] of nodes.entries()) {
+                if (node !== void 0) {
+                  loadedByReference.set(
+                    refKey({ kind, id: requireDefined(ids[index]) }),
+                    node
+                  );
+                }
+              }
+              return;
+            }
+            const rows = backend.getNodes === void 0 ? await Promise.all(
+              ids.map((id) => backend.getNode(this.graphId, kind, id))
+            ) : await backend.getNodes(this.graphId, kind, ids);
+            const includeTombstoned = coordinate?.valid.mode === "includeTombstones";
+            for (const row of rows) {
+              if (row === void 0) continue;
+              if (!includeTombstoned && row.deleted_at !== void 0) continue;
+              loadedByReference.set(
+                refKey({ kind, id: row.id }),
+                rowToNode(row)
+              );
+            }
+          })
+        );
+        return references.map(
+          (reference) => loadedByReference.get(refKey(reference))
+        );
+      }
+    };
+  }
   // === Graph Lifecycle ===
   /**
    * Hard-deletes all data for this graph from the database.
@@ -18602,6 +19980,9 @@ var StoreImplementation = class _StoreImplementation {
       if (this.#revisionTrackingEnabled) {
         await lockRecordedGraphWrite(target, this.graphId);
       }
+      if (this.#graph.identity !== void 0) {
+        await lockIdentityGraph(target, this.graphId);
+      }
       const previousRevision = this.#revisionTrackingEnabled && !this.#captureEnabled ? await readRecordedClock(target, this.#sqlSchema(), this.graphId) : void 0;
       await target.clearGraph(this.graphId);
       if (this.#revisionTrackingEnabled && !this.#captureEnabled) {
@@ -18764,12 +20145,40 @@ var StoreImplementation = class _StoreImplementation {
         this.graphId
       );
     }
-    const committed = classification.requireEmpty.length > 0 ? await commitEvolvedSchemaWhenRequiredKindsAreEmpty(
+    const identityCandidate = merged.identity === void 0 ? void 0 : this.#cloneWithGraph(merged, void 0);
+    const identityProvisioning = identityCandidate === void 0 ? void 0 : await ensureIdentitySchemaStorage(
+      this.#baseBackend,
+      this.#sqlSchema(),
+      {
+        graphId: this.graphId,
+        enablement: false,
+        // The evolved graph's registry — the one the candidate's own
+        // preflight rebuilds through, so the predicate and the fill agree
+        // on which assertions count.
+        registry: buildKindRegistry(merged)
+      }
+    );
+    const committed = identityCandidate === void 0 ? classification.requireEmpty.length > 0 ? await commitEvolvedSchemaWhenRequiredKindsAreEmpty(
       this.#backend,
       merged,
       activeRow.version,
       classification
-    ) : await commitNewSchemaVersion(this.#backend, merged, activeRow.version);
+    ) : await commitNewSchemaVersion(this.#backend, merged, activeRow.version) : await commitNewSchemaVersionWithPreflight(
+      this.#backend,
+      merged,
+      activeRow.version,
+      async (target) => {
+        await assertEvolvedSchemaRequiredKindsEmpty(
+          target,
+          this.graphId,
+          classification
+        );
+        await identityCandidate.identitySchemaPreflight(
+          target,
+          identityProvisioning?.provisionInCommit ?? []
+        );
+      }
+    );
     await materializeVectorContributions(this.#backend, merged);
     const evolved = this.#cloneWithGraph(
       merged,
@@ -19136,6 +20545,169 @@ var StoreImplementation = class _StoreImplementation {
     const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(baseline) : [];
     return repair(this.graphId, vectorSlots);
   }
+  /**
+   * Read-only readiness check for the search projections: is search
+   * coherent with the graph right now, or is a query about to hit a
+   * degraded index?
+   *
+   * The read-only half of {@link Store.repairContributions}, and the
+   * bottom rung of the contribution health ladder — probe (read) →
+   * `repairContributions()` (incremental, non-destructive) →
+   * {@link Store.rebuildContribution} (destructive full reset). It shares
+   * the detection logic of the other two exactly: a second implementation
+   * would be free to disagree with the one the hot-path gate consults,
+   * and a health check that disagrees with the gate is worse than none.
+   *
+   * Writes nothing — no DDL, no marker writes, no effect on the
+   * per-instance caches the hot path relies on — so it is safe on a read
+   * path, on a replica, and under a least-privilege role. That is the
+   * whole reason it exists: the alternative for a caller who wants to
+   * know whether search is ready was to run `repairContributions()`, a
+   * write with repair side effects, and hope.
+   *
+   * One entry per search projection that this graph actually declares
+   * contributions for. A projection with none is omitted rather than
+   * reported `ready`, so an empty `entries` array means "nothing to
+   * assess" — never "assessed and healthy". Use
+   * {@link Store.verifyContributions} for the structured per-table
+   * diagnostics behind a `degraded` entry.
+   *
+   * @throws {ConfigurationError} when the backend provisions
+   *   contributions but cannot probe its own catalog. Answering `ready`
+   *   without having looked is the one answer this method must never
+   *   give. A backend with no contribution machinery at all has nothing
+   *   to assess and resolves to empty entries instead.
+   */
+  async probeContributions() {
+    const backend = this.#baseBackend;
+    const probe = backend.probeContributions;
+    if (probe === void 0) {
+      if (backend.capabilities.contributions?.supported !== true) {
+        return { entries: [] };
+      }
+      throw new ConfigurationError(
+        "probeContributions requires a backend that can probe its catalog for contribution tables.",
+        {
+          backend: backend.dialect,
+          capability: "contributions",
+          operation: "probe"
+        }
+      );
+    }
+    const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(this.#graph) : [];
+    const entries = await probe(this.graphId, vectorSlots);
+    const revision = await this.revisionNow();
+    return {
+      ...revision === void 0 ? {} : { graphRevision: revision },
+      entries
+    };
+  }
+  /**
+   * Destructively rebuilds one search projection for THIS graph: clears the
+   * graph's rows from the projection's storage, recreates that storage from
+   * the current DDL when recreating it is safe, reconstructs the content
+   * from the node rows, and stamps the durable marker at the current
+   * signature.
+   *
+   * **Scoped to this graph.** The fulltext table is one physical table
+   * holding every graph's rows, keyed by `graph_id`, and this method is
+   * fenced per graph — so it removes only this graph's rows
+   * (`DELETE ... WHERE graph_id`, the same statement `clear()` uses) and
+   * escalates to dropping and recreating the table only when no other graph
+   * has rows in it. That drop is the one repair for storage provisioned at a
+   * shape the current DDL no longer produces; when another graph's content
+   * is in the way it is refused
+   * ({@link ContributionRebuildUnsupportedError}, reason
+   * `shared-storage-in-use`) rather than taken, because fulltext content is
+   * reconstructed from a graph's own nodes through its own schema and no
+   * other process can put back what the drop would destroy.
+   *
+   * The top rung of the health ladder, and the repair
+   * {@link Store.repairContributions} deliberately refuses to perform.
+   * Never reachable from that method — a `stale` contribution's table
+   * exists at the *old* shape, so the ordinary ensure path's idempotent
+   * `CREATE ... IF NOT EXISTS` no-ops and re-stamping the marker there
+   * would leave it blessing a table whose shape is wrong, which is
+   * exactly what the drift guard exists to prevent. Only a recreate makes
+   * the ensure meaningful, and destroying content is a decision stated at
+   * the call site rather than reached through a flag named `force`.
+   *
+   * **This destroys this graph's index content.** For `"fulltext"` nothing
+   * is permanently lost: the searchable content is derived from node
+   * properties TypeGraph already stores, so the refill reconstructs it in
+   * the same transaction. Nodes whose stored `props` cannot be read as an
+   * object are counted in `skipped` and are absent from the rebuilt index —
+   * `store.search.rebuildFulltext()` reports their ids individually.
+   *
+   * Atomic: the clear (or drop), recreate, refill, and stamp all run inside
+   * one transaction under the same per-graph fence as a schema commit, plus
+   * a database-scoped advisory lock serializing this contribution's DDL
+   * across graphs, so an interrupted rebuild leaves the contribution exactly
+   * as it was rather than attested-but-empty.
+   *
+   * The cost differs by path, and only one of them is a maintenance-window
+   * operation. A rebuild that drops and recreates the shared table takes
+   * `ACCESS EXCLUSIVE` on it before deciding to — the verdict "no other
+   * graph has rows here" is only sound under the exclusion the drop needs —
+   * so on PostgreSQL every graph's fulltext writers wait for the whole
+   * refill. That was already true of the drop itself, which holds the same
+   * lock to commit; the exclusion now merely starts a few statements
+   * earlier. The graph-scoped path takes no table lock at all: its
+   * `DELETE ... WHERE graph_id` is transactional and touches only this
+   * graph's rows, so it never makes another graph's writers wait.
+   * `store.search.rebuildFulltext()` remains the incremental, resumable way
+   * to refresh content when the storage shape is fine.
+   *
+   * @throws {ContributionRebuildUnsupportedError} for `"vector"`, always:
+   *   TypeGraph stores the vectors callers supply and never the inputs
+   *   that produced them, so embeddings exist only in the storage a
+   *   rebuild would drop and there is nothing to reconstruct them from.
+   *   `store.reembedVectorField(kind, fieldPath, { embed })` is the
+   *   sanctioned destructive path — it takes the callback that can
+   *   regenerate what the drop destroys. Also thrown when the active
+   *   strategy declares no teardown DDL, when the backend has no
+   *   transactional schema fence to make the sequence atomic, and when the
+   *   recorded shape is stale but the storage that would have to be
+   *   recreated holds another graph's rows (`shared-storage-in-use`). Every
+   *   one of these refuses before anything is dropped or deleted.
+   * @throws {ConfigurationError} when the backend cannot rebuild
+   *   strategy-owned contributions at all.
+   */
+  async rebuildContribution(scope, options) {
+    const backend = this.#baseBackend;
+    const rebuild = backend.rebuildContribution;
+    if (rebuild === void 0) {
+      throw new ConfigurationError(
+        "rebuildContribution requires a backend that can drop, recreate, and re-stamp strategy-owned contribution tables.",
+        {
+          backend: backend.dialect,
+          capability: "contributions",
+          operation: "rebuild"
+        }
+      );
+    }
+    await this.#loadCaughtUp("rebuild");
+    const registry = this.#registry;
+    const graphId = this.graphId;
+    return rebuild(graphId, scope, async (target) => {
+      if (scope !== "fulltext") {
+        throw new ContributionRebuildUnsupportedError(
+          "vector-source-unavailable",
+          { graphId, contribution: scope, backend: backend.dialect }
+        );
+      }
+      const result = await repopulateFulltextInTransaction(
+        { graphId, registry },
+        target,
+        options?.pageSize === void 0 ? {} : { pageSize: options.pageSize }
+      );
+      return {
+        processed: result.processed,
+        repopulated: result.upserted,
+        skipped: result.skipped
+      };
+    });
+  }
   /**
    * Removes extension kinds from the schema with cascading edge and
    * ontology cleanup. Two-phase by design:
@@ -19183,10 +20755,19 @@ var StoreImplementation = class _StoreImplementation {
     const compileTimeGraph = stripGraphExtension(this.#graph);
     const merged = plan.document === void 0 ? compileTimeGraph : mergeGraphExtension(compileTimeGraph, plan.document);
     const finalGraph = applyDeprecatedKinds(merged, baseline.deprecatedKinds);
-    const committedRow = await commitNewSchemaVersion(
+    const identityCascade = await this.#identityRemovalPreflight(
+      finalGraph,
+      plan.removedNodeKinds
+    );
+    const committedRow = identityCascade === void 0 ? await commitNewSchemaVersion(
       this.#backend,
       finalGraph,
       activeRow.version
+    ) : await commitNewSchemaVersionWithPreflight(
+      this.#backend,
+      finalGraph,
+      activeRow.version,
+      identityCascade
     );
     const recordKindRemoval = this.#backend.recordKindRemoval;
     if (recordKindRemoval !== void 0) {
@@ -19224,6 +20805,35 @@ var StoreImplementation = class _StoreImplementation {
     }
     return evolved;
   }
+  /**
+   * The identity cascade `removeKinds()` commits with, or `undefined` when the
+   * removal cannot touch the assertion ledger.
+   *
+   * Identity being switched OFF is not that case: disabling identity retains
+   * the assertion rows, so a graph with no profile can still hold assertions
+   * naming the kinds being removed. Those rows are cascaded too — otherwise
+   * they survive as current orphans that a later re-enablement filters out of
+   * the closure while raw ledger reads and merge staging still see them. What
+   * the profile's absence does remove is the closure contract, so the repair
+   * pass is skipped and the ledger cleanup runs alone — and a graph that has no
+   * such rows keeps committing through the plain schema-commit primitive.
+   */
+  async #identityRemovalPreflight(finalGraph, removedNodeKinds) {
+    if (removedNodeKinds.length === 0) return void 0;
+    const repairClosure = finalGraph.identity !== void 0;
+    if (!repairClosure && !await identityKindCascadeNeeded(
+      this.#backend,
+      this.#sqlSchema(),
+      this.graphId,
+      removedNodeKinds
+    )) {
+      return void 0;
+    }
+    const candidate = this.#cloneWithGraph(finalGraph, void 0);
+    return async (target) => candidate.removeIdentityKindsInSchemaPreflight(target, removedNodeKinds, {
+      repairClosure
+    });
+  }
   /**
    * Runs the data-cleanup phase for any kinds removed via
    * `removeKinds()` whose data has not yet been deleted on this
@@ -19326,10 +20936,10 @@ var StoreImplementation = class _StoreImplementation {
     const getPendingKindRemovals = this.#backend.getPendingKindRemovals;
     if (getPendingKindRemovals === void 0) return;
     const addedNodes = Object.keys(merged.nodes).filter(
-      (kind) => !(kind in baseline.nodes)
+      (kind) => !hasOwnKey(baseline.nodes, kind)
     );
     const addedEdges = Object.keys(merged.edges).filter(
-      (kind) => !(kind in baseline.edges)
+      (kind) => !hasOwnKey(baseline.edges, kind)
     );
     if (addedNodes.length === 0 && addedEdges.length === 0) return;
     await ensureFocusedStatusTable(
@@ -19386,6 +20996,7 @@ var StoreImplementation = class _StoreImplementation {
     return (ctx, fn) => this.#withBulkOperationHooks(ctx, fn);
   }
   #createNodeOperationContext(runHooks = this.#immediateHookRunner(), runBulkHooks = this.#immediateBulkHookRunner()) {
+    const identityConfig = this.#graph.identity;
     return {
       graph: this.#graph,
       graphId: this.graphId,
@@ -19394,6 +21005,31 @@ var StoreImplementation = class _StoreImplementation {
       revisionTrackingEnabled: this.#revisionTrackingEnabled,
       revisionSchema: this.#sqlSchema(),
       registry: this.#registry,
+      ...identityConfig === void 0 ? {} : {
+        identity: {
+          lock: (target) => lockIdentityGraph(target, this.graphId),
+          foldCreated: (target, references) => foldIdentityForCreatedNodes(
+            {
+              graphId: this.graphId,
+              registry: this.#registry,
+              sameIdAcrossKinds: identityConfig.sameIdAcrossKinds,
+              schema: this.#sqlSchema()
+            },
+            target,
+            references
+          ),
+          detachDeleted: (target, ref, mode) => detachIdentityForNode(
+            {
+              graphId: this.graphId,
+              sameIdAcrossKinds: identityConfig.sameIdAcrossKinds,
+              schema: this.#sqlSchema()
+            },
+            target,
+            ref,
+            mode
+          )
+        }
+      },
       createOperationContext: (operation, entity, kind, id) => this.#createOperationContext(operation, entity, kind, id),
       withOperationHooks: runHooks,
       createBulkOperationContext: (operation, kind) => ({
@@ -19423,6 +21059,11 @@ var StoreImplementation = class _StoreImplementation {
    * Decorates the query execution port so hooks observe each statement the
    * query builder submits to the backend. A selective-projection retry
    * therefore emits two independent start/end pairs with their actual SQL.
+   *
+   * Decoration goes through {@link createBackendOverlay}, which carries the
+   * projection's serialized-resource ownership: the hooked backend still
+   * executes on the source's connection, so it must answer the same "shares one
+   * serialized connection" question as its source.
    */
   #createHookedQueryBackend(backend) {
     if (this.#hooks.onQueryStart === void 0 && this.#hooks.onQueryEnd === void 0 && this.#hooks.onError === void 0) {
@@ -19431,8 +21072,7 @@ var StoreImplementation = class _StoreImplementation {
     const executeRaw = backend.executeRaw;
     const compileSql = backend.compileSql;
     const projected = createGraphBackendProjection(backend);
-    return {
-      ...projected,
+    return createBackendOverlay(projected, {
       execute: (query) => {
         const compiled = compileSql === void 0 ? renderSql(query, backend.dialect) : compileSql(query);
         return this.#withQueryHooks(
@@ -19448,7 +21088,7 @@ var StoreImplementation = class _StoreImplementation {
           () => executeRaw(sqlText, params)
         )
       }
-    };
+    });
   }
   async #withQueryHooks(sql2, params, execute) {
     const ctx = {
@@ -19804,10 +21444,70 @@ async function createStoreWithSchema(graph, backend, options) {
     prepared.result
   ];
 }
-async function assertHistorySchemaOnOpen(backend, options) {
+async function assertHistorySchemaOnOpen(backend, graph, options) {
   if (options?.history !== true) return;
   const schema = options.schema === void 0 ? createSqlSchema(backend.tableNames) : requireSqlSchema(options.schema, "store schema");
-  await assertCurrentRecordedSchema(backend, schema);
+  await assertCurrentRecordedSchema(
+    backend,
+    schema,
+    graph.identity !== void 0
+  );
+}
+var IDENTITY_ONTOLOGY_META_EDGES = /* @__PURE__ */ new Set([
+  META_EDGE_DISJOINT_WITH,
+  META_EDGE_EQUIVALENT_TO,
+  META_EDGE_SAME_AS,
+  META_EDGE_SUB_CLASS_OF
+]);
+function identityOntologyChanged(before, after) {
+  function relevantRelations(schema) {
+    return schema.ontology.relations.filter((relation) => IDENTITY_ONTOLOGY_META_EDGES.has(relation.metaEdge)).map(
+      (relation) => JSON.stringify([relation.metaEdge, relation.from, relation.to])
+    ).toSorted();
+  }
+  return JSON.stringify(relevantRelations(before)) !== JSON.stringify(relevantRelations(after));
+}
+var IDENTITY_GATE_CODES = {
+  enablement: "IDENTITY_ENABLEMENT_PENDING",
+  profile: "IDENTITY_PROFILE_MIGRATION_PENDING",
+  ontology: "IDENTITY_SCHEMA_MIGRATION_PENDING"
+};
+async function ensureSchemaWithIdentityPrecedence(backend, graph, options, gate) {
+  try {
+    return await ensureSchema(backend, graph, options);
+  } catch (error) {
+    if (gate === void 0 || !isIdentityOnlyBreakingChange(error)) throw error;
+    throw identityMigrationRequiredError(graph.id, gate, {
+      blockedBy: "breaking-change",
+      cause: error
+    });
+  }
+}
+function isIdentityOnlyBreakingChange(error) {
+  if (!(error instanceof MigrationError)) return false;
+  const diff = "diff" in error.details ? error.details.diff : void 0;
+  if (diff?.identity?.severity !== "breaking") return false;
+  return ![
+    ...diff.nodes,
+    ...diff.edges,
+    ...diff.ontology,
+    ...diff.indexes
+  ].some((change) => change.severity === "breaking");
+}
+function identityMigrationRequiredError(graphId, gate, context) {
+  const blocker = context.blockedBy === "breaking-change" ? "but the change is breaking and has not been applied." : "but autoMigrate is disabled and the change is pending.";
+  return new ConfigurationError(
+    `Changing Operational Identity semantics requires the schema migration to commit, ${blocker}`,
+    {
+      code: IDENTITY_GATE_CODES[gate],
+      graphId,
+      ...context.pendingVersion === void 0 ? {} : { pendingVersion: context.pendingVersion }
+    },
+    {
+      cause: context.cause,
+      suggestion: "Apply the migration explicitly with migrateSchema(backend, graph, activeVersion) \u2014 it commits the new version and rebuilds the identity closure in the same transaction \u2014 or, for a change that is not breaking, enable autoMigrate."
+    }
+  );
 }
 async function prepareStoreWithSchema(graph, backend, options) {
   const {
@@ -19815,11 +21515,70 @@ async function prepareStoreWithSchema(graph, backend, options) {
     activeRow,
     storedSchema
   } = await loadAndMergeGraphExtensionDocument(backend, graph);
-  const result = await ensureSchema(backend, merged, {
-    ...options,
+  const identityProfileChanged = activeRow !== void 0 && storedSchema?.identity?.sameIdAcrossKinds !== merged.identity?.sameIdAcrossKinds;
+  const identityInitialization = activeRow === void 0 && merged.identity !== void 0;
+  const identityEnablement = identityInitialization || identityProfileChanged && storedSchema?.identity === void 0 && merged.identity !== void 0;
+  const identitySemanticsChanged = identityProfileChanged || activeRow !== void 0 && storedSchema !== void 0 && merged.identity !== void 0 && identityOntologyChanged(
+    storedSchema,
+    serializeSchema(merged, activeRow.version + 1)
+  );
+  const identityGate = identitySemanticsChanged ? identityEnablement ? "enablement" : identityProfileChanged ? "profile" : "ontology" : void 0;
+  const identityProfile = merged.identity;
+  if (identityProfile !== void 0) {
+    const resolvedIdentitySchema = options?.schema === void 0 ? createSqlSchema(backend.tableNames) : requireSqlSchema(options.schema, "store schema");
+    const identityRegistry = buildKindRegistry(merged);
+    await ensureIdentitySchemaStorage(backend, resolvedIdentitySchema, {
+      graphId: merged.id,
+      enablement: identityEnablement,
+      registry: identityRegistry,
+      // A derived relation this library version added, absent from (or left
+      // empty in) a database that predates it, is created and FILLED as one
+      // unit here — never created now and filled at the end of boot. Between
+      // those two points sit the schema commit, the history assertion, three
+      // materialization steps and an index build, and for that whole window an
+      // empty separation relation would answer "not separated" to every
+      // concurrent `assertSame`. See `ensureIdentitySchemaStorage`.
+      //
+      // Withheld when a schema commit is gated on an identity SEMANTICS
+      // change: that commit's own preflight creates AND rebuilds inside the
+      // commit transaction, under the semantics being committed. Filling here
+      // would instead derive classes from semantics this database has not
+      // accepted yet — and would keep them if the commit were then refused.
+      // Nothing is provisioned on that path either, so a refused commit leaves
+      // the relation absent rather than readable-empty, and the next open of a
+      // graph whose semantics ARE committed heals it here.
+      ...identityGate === void 0 ? {
+        recomputeDerivedRelations: (target) => rebuildIdentityClosureForContext({
+          backend: target,
+          graphId: merged.id,
+          registry: identityRegistry,
+          schema: resolvedIdentitySchema,
+          sameIdAcrossKinds: identityProfile.sameIdAcrossKinds
+        })
+      } : {}
+    });
+  }
+  const ensureOptions = {
+    // The fallback is not useless: spreading `options` while it is possibly
+    // undefined makes TypeScript distribute the StoreOptions union through
+    // the literal and reject the call below.
+    // eslint-disable-next-line unicorn/no-useless-fallback-in-spread
+    ...options ?? {},
     preloaded: { activeRow, storedSchema }
-  });
-  await assertHistorySchemaOnOpen(backend, options);
+  };
+  const result = await ensureSchemaWithIdentityPrecedence(
+    backend,
+    merged,
+    ensureOptions,
+    identityGate
+  );
+  if (identityGate !== void 0 && result.status === "pending") {
+    throw identityMigrationRequiredError(merged.id, identityGate, {
+      blockedBy: "auto-migrate-disabled",
+      pendingVersion: result.version
+    });
+  }
+  await assertHistorySchemaOnOpen(backend, merged, options);
   await materializeRuntimeContributions(backend, merged.id);
   await materializeVectorContributions(backend, merged);
   if (options?.systemIndexes !== "skip") {
@@ -19871,15 +21630,14 @@ async function materializeSystemIndexesOnBoot(backend, graphId, result) {
 }
 async function createVerifiedStore(graph, backend, options) {
   const prepared = await prepareVerifiedStore(graph, backend, options);
-  return [
-    new StoreImplementation(
-      prepared.graph,
-      backend,
-      options,
-      prepared.schemaMetadata
-    ),
-    prepared.result
-  ];
+  const store = new StoreImplementation(
+    prepared.graph,
+    backend,
+    options,
+    prepared.schemaMetadata
+  );
+  await store.validateIdentity();
+  return [store, prepared.result];
 }
 async function prepareVerifiedStore(graph, backend, options) {
   const {
@@ -19887,7 +21645,7 @@ async function prepareVerifiedStore(graph, backend, options) {
     activeRow,
     result
   } = await loadAndVerifyGraph(backend, graph);
-  await assertHistorySchemaOnOpen(backend, options);
+  await assertHistorySchemaOnOpen(backend, merged, options);
   return {
     graph: merged,
     result,
@@ -19896,19 +21654,16 @@ async function prepareVerifiedStore(graph, backend, options) {
 }
 async function createVerifiedAdapterStore(graph, backend, options) {
   const prepared = await prepareVerifiedStore(graph, backend, options);
-  return [
-    asAdapterStoreSurface(
-      new AdapterStoreImplementation(
-        prepared.graph,
-        backend,
-        options,
-        prepared.schemaMetadata
-      )
-    ),
-    prepared.result
-  ];
+  const store = new AdapterStoreImplementation(
+    prepared.graph,
+    backend,
+    options,
+    prepared.schemaMetadata
+  );
+  await store.validateIdentity();
+  return [asAdapterStoreSurface(store), prepared.result];
 }
 
 export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createAdapterStore, createAdapterStoreWithSchema, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedAdapterStore, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-ID4WXTKL.js.map
-//# sourceMappingURL=chunk-ID4WXTKL.js.map
+//# sourceMappingURL=chunk-7Z5OR7KO.js.map
+//# sourceMappingURL=chunk-7Z5OR7KO.js.map