@nicia-ai/typegraph 0.65.0 → 0.66.1

package/dist/{chunk-MIBWA6HX.js → chunk-TR7QTODF.js}

@@ -1,19 +1,19 @@
-import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG, normalizeRowTimestamp, normalizeRequiredRowTimestamp, buildHardDeleteEdgeClaimsByNodeKind, buildHardDeleteUniquesByConcreteKind, buildHardDeleteEdgeClaimsByEdgeKind } from './chunk-HTSJTWUT.js';
+import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG, normalizeRowTimestamp, normalizeRequiredRowTimestamp, buildHardDeleteEdgeClaimsByNodeKind, buildHardDeleteUniquesByConcreteKind, buildHardDeleteEdgeClaimsByEdgeKind } from './chunk-OF63ZHSD.js';
 import { assertRecordedInstantOwnershipMatch, resolveRecordedTimeOwnership, requireRecordedTime, isEngineNativeRecordedReadBinding } from './chunk-XELE7ZOX.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeReplacementBatch, prepareNodeReplacement, executeNodeResolvedMutationSet, executeNodeUpsertUpdateBatch, executeNodeSetUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, normalizePersistedEdgeMatchProps, assertValidityEndMutation, assertClearValidToSupported, buildEdgeMatchKey, resolveAtomicEdgeConvergenceExecutor, resolveEdgeMatchIdentityStorage, runHookedWritePlan, edgeWritePlan, resolveAtomicEdgeDeleteBatchExecutor, runWritePlan, runAtomicProgramWithHooks, unsupportedResolvedMutationSet, resolveAtomicEdgeResolvedMutationSetExecutor, withAlreadyExistsTranslation, ResolvedMutationSetMoved, appliedResolvedMutationSet, edgeWriteNeedsConstraintFence, writeResultAlwaysChanges, resolveAtomicEdgeBatchExecutor, nestedManagedWriteTarget, runResolvedMutationSetConverging, canonicalPersistedJsonValue, assertAtomicDeleteSchemaFenceMatched, edgeMatchIdentityUpdateRefusal, resolveAtomicEdgeResolvedUpdateBatchExecutor, atomicResolvedUpdateAttemptBudget, createEdgeBatchValidationBackend, canFuseSchemaFenceInFirstWrite, isAutocommitSingleStatementWrite, runAutocommitSingleStatementWritePlan, classifyDurableEdgeBatchOutcomes, rowToEdgeMeta, rowToNodeMeta, checkCardinalityConstraint, validityEndAfterMutation, assertsStoredWindowState, unfencedTarget, AutocommitWriteRequiresTransaction } from './chunk-QFEO4M5W.js';
-import { applyResolvedNodeClaims, assertFulltextMember, getEmbeddingFields, computeFulltextContent } from './chunk-GKSAEUX6.js';
-import { isBundledRootAutocommitEligible } from './chunk-RQPCUHIH.js';
-import { edgeCardinalityClaimTarget, edgeCardinalityClaimRefusal, edgeCardinalityClaim, edgeCardinalityClaimMode, claimEdgeCardinality } from './chunk-G6T23JU7.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeReplacementBatch, prepareNodeReplacement, executeNodeResolvedMutationSet, executeNodeUpsertUpdateBatch, executeNodeSetUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, normalizePersistedEdgeMatchProps, assertValidityEndMutation, assertClearValidToSupported, buildEdgeMatchKey, resolveAtomicEdgeConvergenceExecutor, resolveEdgeMatchIdentityStorage, runHookedWritePlan, edgeWritePlan, resolveAtomicEdgeDeleteBatchExecutor, runWritePlan, runAtomicProgramWithHooks, unsupportedResolvedMutationSet, resolveAtomicEdgeResolvedMutationSetExecutor, withAlreadyExistsTranslation, ResolvedMutationSetMoved, appliedResolvedMutationSet, edgeWriteNeedsConstraintFence, writeResultAlwaysChanges, resolveAtomicEdgeBatchExecutor, nestedManagedWriteTarget, runResolvedMutationSetConverging, canonicalPersistedJsonValue, assertAtomicDeleteSchemaFenceMatched, edgeMatchIdentityUpdateRefusal, resolveAtomicEdgeResolvedUpdateBatchExecutor, atomicResolvedUpdateAttemptBudget, createEdgeBatchValidationBackend, canFuseSchemaFenceInFirstWrite, isAutocommitSingleStatementWrite, runAutocommitSingleStatementWritePlan, classifyDurableEdgeBatchOutcomes, rowToEdgeMeta, rowToNodeMeta, checkCardinalityConstraint, validityEndAfterMutation, assertsStoredWindowState, unfencedTarget, AutocommitWriteRequiresTransaction } from './chunk-RTPMG6LQ.js';
+import { applyResolvedNodeClaims, assertFulltextMember, getEmbeddingFields, computeFulltextContent } from './chunk-FXOFJ4FS.js';
+import { isBundledRootAutocommitEligible } from './chunk-6ECNYQDW.js';
+import { edgeCardinalityClaimTarget, edgeCardinalityClaimRefusal, edgeCardinalityClaim, edgeCardinalityClaimMode, claimEdgeCardinality } from './chunk-CDKNGCE7.js';
 import { resolveBackendFulltext } from './chunk-N535PWMA.js';
-import { AtomicEdgeBatchEndpointRefusalError, AtomicEdgeConvergenceTombstoneRefusalError, AtomicEdgeDeleteIdentityRefusalError, AtomicEdgeBatchCardinalityRefusalError } from './chunk-WTMSUIRO.js';
-import { loadAndMergeGraphExtensionDocument, serializeSchema, buildKindRegistry, ensureIdentitySchemaStorage, loadAndVerifyGraph, identitySchemaCommitPreflight, getSchemaChanges, requiresMigration, inspectAdoptedIdentityStorage, parseSerializedSchema, mergeGraphExtension, commitNewSchemaVersion, commitNewSchemaVersionWithPreflight, planRemovals, stripGraphExtension, applyDeprecatedKinds, identityKindCascadeNeeded, ensureSchema, loadActiveSchemaWithBootstrap, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, prepareNewSchemaVersion, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-53ZEBIMD.js';
+import { AtomicEdgeBatchEndpointRefusalError, AtomicEdgeConvergenceTombstoneRefusalError, AtomicEdgeDeleteIdentityRefusalError, AtomicEdgeBatchCardinalityRefusalError } from './chunk-UFKYMQJ5.js';
+import { loadAndMergeGraphExtensionDocument, serializeSchema, buildKindRegistry, ensureIdentitySchemaStorage, loadAndVerifyGraph, identitySchemaCommitPreflight, getSchemaChanges, requiresMigration, inspectAdoptedIdentityStorage, parseSerializedSchema, mergeGraphExtension, commitNewSchemaVersion, commitNewSchemaVersionWithPreflight, planRemovals, stripGraphExtension, applyDeprecatedKinds, identityKindCascadeNeeded, ensureSchema, loadActiveSchemaWithBootstrap, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, prepareNewSchemaVersion, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-WB55URNM.js';
 import { countSchemaKindRows } from './chunk-RFMSZ7CF.js';
 import { getTypeName } from './chunk-Q2SPDS3B.js';
-import { loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode, rebuildIdentityClosureForContext, assertEdgeMatchIdentityBackendSupport } from './chunk-THK3SCQA.js';
-import { storeRuntime, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, lockRecordedGraphWrite, refuseEngineNativeRecordedIdentityRead, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockSchemaVersionForStoreWrite, createMutationWitness, registerRecordedIdentityMutationWitness, bindEvolvedTransactionStore, runInTransactionContext, forceRecordedGraphRevision, TRANSACTION_RUNTIME, bindTransactionStore, mintsOriginNamespacedAnchor, ensureRevisionOriginsRelation, generateId, runInWriteTransaction, assertCurrentRecordedSchema, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, withRecordedFlushObserver, withTransactionSchemaFenceLease, withWriteTransactionSession, resetRevisionOrigin, advanceRevisionClock, validateEdgeProps, diagnoseFusedSchemaFenceNoRow, getEdgeRowsByIds, memoizeLeasedSchemaFence, inheritRecordedTransactionBindings, getNodeRowsByIds, hasLeasedSchemaFence, closeRecordedHardDeletedKind, recordedBindParamBudget, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess } from './chunk-337ONI2I.js';
-import { isParameterRef, resolveParameterValueType, validateAggregateOperand, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, extractFulltextMatchPredicates, extractVectorSimilarityPredicates, withPinnedReadInstant, resolveBatchWriteVerdict, batchRefusalSuffix, batchRefusalDetails, canonicalEqual, runRetriedUnit, baseField, objectField, arrayField, dateField, numberField, isAggregateExpression, sortedReplacer, compilePredicateExpression, assertRecursiveTraversalSupported, compileFieldValue, compileKindFilter, compileTemporalFilter, currentReadInstant, compileFieldValueFromColumn, compileDatabaseExpression, expressionContainsAggregate, chunk, sqlValueList, getNodeKindsForAlias, getFieldPointer, visitExpressionChildren, groupBy, delay, buildPredicateIndex, requireRecursiveTraversalVerdict, isOptimisticRetryTier, OPTIMISTIC_RETRY_ATTEMPTS, currentReadInstantFor, extractTemporalOptions, getPredicatesForAlias, getHybridTargetAlias, compilePredicateClauses, compileLegacyAggregateExpression } from './chunk-4VTCIEK3.js';
-import { batchPointReadVerdict, statementExecutionVerdict, createClaimsVerdictThunk, endpointSetReadVerdict, uniqueSidecarBatchVerdict, contributionHealthVerdict, recordedRevisionOriginsVerdict, requireExtras, requireCatalog } from './chunk-EVGZ2TRQ.js';
-import { assumeRecursiveTraversalSupported, withRecordedRelationsPrecondition, backendDerivationRoot, createSqlSchema, requireSqlSchema, resolveRecursiveTraversal, resolveWriteFencePlan, refuseUnfencedOperationalIdentity, refuseUnfencedClockAllocation, requireExternalRecordedReadSource, createRecordedReadBinding, createEngineRecordedReadBinding, recordedReadSchemaFor, runOptionallyInTransaction, createTransactionReadBackend, bindExtraIfReachable, BATCH_POINT_READ, CONTRIBUTION_HEALTH, bindExtra, projectGraphBackend, deriveBackend, DEFAULT_SQL_SCHEMA, vectorSlotKey, requireRecordedReadBinding, GRAPH_BACKEND_PROJECTION_KEYS, projectBackend, rowPropsToObject, recordedReadSqlSchema, endpointSetReadMembers, INTERNAL_TEMPORARY_WRITES, postgresReadWriteRefusedSqlState, assertGraphCommandConvergenceIsolation, isSchemaFencedInsertEligible, executeAuthoritativeGraphCommand, isMissingTableError, postgresTemporaryTableUnavailableSqlState, assertRecursiveTraversal, isPostgresConcurrentDdlRaceError, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-AD3NLSV5.js';
+import { loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode, rebuildIdentityClosureForContext, assertEdgeMatchIdentityBackendSupport } from './chunk-SYXTWPX6.js';
+import { storeRuntime, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, lockRecordedGraphWrite, refuseEngineNativeRecordedIdentityRead, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockSchemaVersionForStoreWrite, createMutationWitness, registerRecordedIdentityMutationWitness, bindEvolvedTransactionStore, withPreAcquiredTransactionSchemaFenceLease, validateNodeProps, withRecordedNodeMutationTarget, diagnoseFusedSchemaFenceNoRow, forceRecordedGraphRevision, TRANSACTION_RUNTIME, bindTransactionStore, mintsOriginNamespacedAnchor, ensureRevisionOriginsRelation, generateId, runInWriteTransaction, assertCurrentRecordedSchema, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, withRecordedFlushObserver, runInTransactionContext, withTransactionSchemaFenceLease, withWriteTransactionSession, resetRevisionOrigin, advanceRevisionClock, validateEdgeProps, getEdgeRowsByIds, memoizeLeasedSchemaFence, inheritRecordedTransactionBindings, getNodeRowsByIds, hasLeasedSchemaFence, closeRecordedHardDeletedKind, recordedBindParamBudget, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess } from './chunk-3SUZXB5X.js';
+import { isParameterRef, resolveParameterValueType, validateAggregateOperand, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, extractFulltextMatchPredicates, extractVectorSimilarityPredicates, withPinnedReadInstant, resolveBatchWriteVerdict, batchRefusalSuffix, batchRefusalDetails, canonicalEqual, runRetriedUnit, baseField, objectField, arrayField, dateField, numberField, isAggregateExpression, sortedReplacer, compilePredicateExpression, assertRecursiveTraversalSupported, compileFieldValue, compileKindFilter, compileTemporalFilter, currentReadInstant, compileFieldValueFromColumn, compileDatabaseExpression, expressionContainsAggregate, chunk, sqlValueList, getNodeKindsForAlias, getFieldPointer, visitExpressionChildren, groupBy, delay, buildPredicateIndex, requireRecursiveTraversalVerdict, isOptimisticRetryTier, OPTIMISTIC_RETRY_ATTEMPTS, currentReadInstantFor, extractTemporalOptions, getPredicatesForAlias, getHybridTargetAlias, compilePredicateClauses, compileLegacyAggregateExpression } from './chunk-4TQOIBWH.js';
+import { batchPointReadVerdict, statementExecutionVerdict, createClaimsVerdictThunk, endpointSetReadVerdict, uniqueSidecarBatchVerdict, contributionHealthVerdict, recordedRevisionOriginsVerdict, requireExtras, requireCatalog } from './chunk-BE75G3M5.js';
+import { assumeRecursiveTraversalSupported, withRecordedRelationsPrecondition, backendDerivationRoot, createSqlSchema, requireSqlSchema, resolveRecursiveTraversal, resolveWriteFencePlan, refuseUnfencedOperationalIdentity, refuseUnfencedClockAllocation, requireExternalRecordedReadSource, createRecordedReadBinding, createEngineRecordedReadBinding, recordedReadSchemaFor, runOptionallyInTransaction, createTransactionReadBackend, bindExtraIfReachable, BATCH_POINT_READ, CONTRIBUTION_HEALTH, bindExtra, projectGraphBackend, deriveBackend, DEFAULT_SQL_SCHEMA, vectorSlotKey, requireRecordedReadBinding, GRAPH_BACKEND_PROJECTION_KEYS, projectBackend, rowPropsToObject, recordedReadSqlSchema, endpointSetReadMembers, INTERNAL_TEMPORARY_WRITES, postgresReadWriteRefusedSqlState, assertGraphCommandConvergenceIsolation, isSchemaFencedInsertEligible, executeAuthoritativeGraphCommand, isMissingTableError, postgresTemporaryTableUnavailableSqlState, assertRecursiveTraversal, isPostgresConcurrentDdlRaceError, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-TU22BFMP.js';
 import { isKnownKind } from './chunk-NMRLVAVN.js';
 import { isEdgeTargetMap, projectTargetKinds, validateEdgeEndpoints, compareClaimTargets, encodeTupleKey, uniquenessClaimTarget, subClassComponent, isSameClaimOwner, DISJOINT_CONSTRAINT_NAME, disjointnessClaimAxis } from './chunk-OXJNL2PW.js';
 import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, nowIso, recordedInstantWallTime, asRecordedInstant, createEngineRecordedInstant, validityWindowContainsInstant, validateStatedValidityLowerBound, validateOptionalCanonicalIsoDate, assertOrderedValidityWindow, preservesImmutableLowerBound, parseRecordedInstant, assertWritableValidityWindow, assertValidRecordedInstant, isCanonicalIsoDate, statedBoundMatchesStored, optionalRecordedInstantParts } from './chunk-CY657YYY.js';
@@ -28,7 +28,7 @@ import { assertVectorMinScore, assertApproximateMetricSupported, vectorScoreExpr
 import { createSchemaIntrospector } from './chunk-UL5SIHSR.js';
 import { isPortableCountDistinctValueType } from './chunk-2V2ZQ5BG.js';
 import { asCompiledSelectSql, sql, isSqlPlaceholder, bindSqlValue, isRawExecutable, markAnnIndexScan, renderSql, annIndexScanTypes, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql, asCompiledTemporaryStatementSql } from './chunk-XDTDSEAE.js';
-import { resolveEmbeddingFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage, getSearchableFields } from './chunk-PC2UBAUB.js';
+import { resolveEmbeddingFields, getSearchableFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage } from './chunk-PC2UBAUB.js';
 import { IncompatibleChangeError } from './chunk-YIB2EVIL.js';
 import { META_EDGE_DISJOINT_WITH, META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS, META_EDGE_SUB_CLASS_OF } from './chunk-JXXDZTMN.js';
 import { canonicalAnnotations, validateProjectionField } from './chunk-OTJNUB6M.js';
@@ -16924,6 +16924,20 @@ function asRawBackend(backend) {
   return backend;
 }
 
+// src/backend/heterogeneous-node-upsert-batch.ts
+var HETEROGENEOUS_NODE_UPSERT_BATCH_FIXED_BIND_COUNT = 5;
+var HETEROGENEOUS_NODE_UPSERT_BATCH_ENTRY_BIND_COUNT = 6;
+function heterogeneousNodeUpsertBatchBindParameterCount(entryCount) {
+  if (!Number.isSafeInteger(entryCount) || entryCount < 1) return;
+  return HETEROGENEOUS_NODE_UPSERT_BATCH_FIXED_BIND_COUNT + entryCount * HETEROGENEOUS_NODE_UPSERT_BATCH_ENTRY_BIND_COUNT;
+}
+function heterogeneousNodeUpsertBatchFitsBindBudget(entryCount, maxBindParameters) {
+  const parameterCount = heterogeneousNodeUpsertBatchBindParameterCount(entryCount);
+  if (parameterCount === void 0) return false;
+  if (maxBindParameters === void 0) return true;
+  return parameterCount <= maxBindParameters;
+}
+
 // src/graph-extension/classify.ts
 function classifyModifications(existing, next) {
   const incompatible = [];
@@ -22017,6 +22031,7 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "tableNames",
   "updateEdge",
   "updateNode",
+  "upsertHeterogeneousNodes",
   "updateResolvedNodesBatch",
   "compareAndSetNode",
   "updateNodeSet",
@@ -26491,6 +26506,15 @@ async function assertEvolvedSchemaRequiredKindsEmpty(backend, graphId, classific
   if (error !== void 0) throw error;
 }
 var IDENTITY_FACADES = /* @__PURE__ */ new WeakMap();
+function callerSuppliedParsedNodeProps(inputProps, parsedCreateProps) {
+  const updateProps = createDataKeyedBag();
+  for (const property of Object.keys(inputProps)) {
+    if (hasOwnKey(parsedCreateProps, property)) {
+      updateProps[property] = parsedCreateProps[property];
+    }
+  }
+  return updateProps;
+}
 var StoreImplementation = class _StoreImplementation {
   [STORE_RUNTIME];
   #graph;
@@ -28607,8 +28631,9 @@ var StoreImplementation = class _StoreImplementation {
     }
     const invoke = fn;
     const executionScope = originalStore === void 0 ? void 0 : scopeBackendExecution(writeTarget);
+    const contextBackend = executionScope?.backend ?? writeTarget;
     const context = this.#buildTransactionContext(
-      executionScope?.backend ?? writeTarget,
+      contextBackend,
       externalTx,
       void 0,
       receiptRecorder
@@ -28616,24 +28641,36 @@ var StoreImplementation = class _StoreImplementation {
     if (originalStore !== void 0) {
       bindEvolvedTransactionStore(context, originalStore, this);
     }
-    const result = await runInTransactionContext(
-      context,
-      async (activeContext) => {
-        try {
-          return await invoke(activeContext);
-        } finally {
-          executionScope?.seal();
+    const finish = async () => {
+      const result = await runInTransactionContext(
+        context,
+        async (activeContext) => {
+          try {
+            return await invoke(activeContext);
+          } finally {
+            executionScope?.seal();
+          }
         }
-      }
-    );
-    const recordedByGraph = mutationWitness?.mutated === true ? /* @__PURE__ */ new Map([[this.graphId, await this.#engineRecordedInstant(txBackend)]]) : await scope.flush();
-    if (!this.#captureEnabled) receiptRecorder.seal();
-    return transactionOutcome(
-      result,
-      receiptRecorder,
-      recordedByGraph,
-      this.graphId
-    );
+      );
+      const recordedByGraph = mutationWitness?.mutated === true ? /* @__PURE__ */ new Map([
+        [this.graphId, await this.#engineRecordedInstant(txBackend)]
+      ]) : await scope.flush();
+      if (!this.#captureEnabled) receiptRecorder.seal();
+      return transactionOutcome(
+        result,
+        receiptRecorder,
+        recordedByGraph,
+        this.graphId
+      );
+    };
+    return this.#captureEnabled ? withPreAcquiredTransactionSchemaFenceLease(
+      {
+        graphId: this.graphId,
+        schemaVersion: this.#schemaMetadata.schemaVersion
+      },
+      [txBackend, scope.backend, writeTarget, contextBackend],
+      finish
+    ) : finish();
   }
   /**
    * Decorates a receipt-enabled transaction `context` with `measure`.
@@ -28701,6 +28738,148 @@ var StoreImplementation = class _StoreImplementation {
       subgraph: (rootId, options) => this.#createSubgraphRead(rootId, options, txBackend, attempt).execute()
     };
   }
+  /** One CTE-backed upsert envelope for plain history-store node kinds. */
+  async #writeNodeUpsertBatch(txBackend, entries, receiptRecorder) {
+    if (entries.length === 0)
+      return [];
+    if (!this.#captureEnabled) {
+      throw new UnsupportedBackendCapabilityError(
+        "tx.writeNodeUpsertBatch()",
+        "recorded heterogeneous node upserts",
+        { history: this.#captureEnabled }
+      );
+    }
+    if (this.#coalescesUnchangedUpserts()) {
+      throw new ConfigurationError(
+        "writeNodeUpsertBatch does not support coalesceUnchangedUpserts.",
+        { code: "HETEROGENEOUS_NODE_BATCH_UNSUPPORTED_COALESCING" }
+      );
+    }
+    if (this.#graph.identity !== void 0) {
+      throw new ConfigurationError(
+        "writeNodeUpsertBatch does not support graphs with operational identity.",
+        { code: "HETEROGENEOUS_NODE_BATCH_UNSUPPORTED_IDENTITY" }
+      );
+    }
+    const schemaVersion = this.#schemaMetadata.schemaVersion;
+    if (schemaVersion === void 0) {
+      throw new ConfigurationError(
+        "writeNodeUpsertBatch requires an initialized schema-fenced Store.",
+        { code: "HETEROGENEOUS_NODE_BATCH_SCHEMA_UNAVAILABLE" }
+      );
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const validated = entries.map((entry2) => {
+      if ("validFrom" in entry2 || "validTo" in entry2 || "clearValidTo" in entry2 || "onImmutableLowerBound" in entry2) {
+        throw new ConfigurationError(
+          "writeNodeUpsertBatch does not support temporal write options.",
+          { code: "HETEROGENEOUS_NODE_BATCH_UNSUPPORTED_TEMPORAL_OPTIONS" }
+        );
+      }
+      if (!hasOwnKey(this.#graph.nodes, entry2.kind)) {
+        throw new KindNotFoundError(entry2.kind, "node", {
+          graphId: this.graphId
+        });
+      }
+      const registration = this.#graph.nodes[entry2.kind];
+      if (registration === void 0) {
+        throw new KindNotFoundError(entry2.kind, "node", {
+          graphId: this.graphId
+        });
+      }
+      if ((registration.unique?.length ?? 0) > 0 || this.#registry.getDisjointKinds(entry2.kind).length > 0 || resolveEmbeddingFields(registration.type.schema).length > 0 || getSearchableFields(registration.type.schema).length > 0) {
+        throw new ConfigurationError(
+          "writeNodeUpsertBatch only supports plain node kinds without identity claims or projections.",
+          {
+            code: "HETEROGENEOUS_NODE_BATCH_UNSUPPORTED_KIND",
+            kind: entry2.kind
+          }
+        );
+      }
+      const key = `${entry2.kind}\0${entry2.id}`;
+      if (seen.has(key)) {
+        throw new ValidationError(
+          `writeNodeUpsertBatch received duplicate node id "${entry2.id}" for kind "${entry2.kind}".`,
+          { entityType: "node", kind: entry2.kind, id: entry2.id, issues: [] }
+        );
+      }
+      seen.add(key);
+      const props = validateNodeProps(registration.type.schema, entry2.props, {
+        kind: entry2.kind,
+        id: entry2.id,
+        operation: "create"
+      });
+      return {
+        kind: entry2.kind,
+        id: entry2.id,
+        props,
+        updateProps: callerSuppliedParsedNodeProps(entry2.props, props)
+      };
+    });
+    if (!heterogeneousNodeUpsertBatchFitsBindBudget(
+      validated.length,
+      txBackend.capabilities.maxBindParameters
+    )) {
+      const maxBindParameters = txBackend.capabilities.maxBindParameters;
+      const parameterCount = heterogeneousNodeUpsertBatchBindParameterCount(
+        validated.length
+      );
+      throw new ConfigurationError(
+        `writeNodeUpsertBatch uses ${parameterCount} bound parameters, exceeding this backend's limit of ${maxBindParameters}.`,
+        {
+          capability: "maxBindParameters",
+          maxBindParameters,
+          parameterCount
+        },
+        {
+          suggestion: "Split the operation into smaller batches before retrying."
+        }
+      );
+    }
+    receiptRecorder?.assertWritable();
+    if (txBackend.upsertHeterogeneousNodes === void 0) {
+      throw new UnsupportedBackendCapabilityError(
+        "tx.writeNodeUpsertBatch()",
+        "exact-session heterogeneous node upsert program",
+        { dialect: txBackend.dialect }
+      );
+    }
+    const rows = await withRecordedNodeMutationTarget(
+      txBackend,
+      this.graphId,
+      (target) => {
+        const upsert = target.upsertHeterogeneousNodes;
+        if (upsert === void 0) {
+          throw new UnsupportedBackendCapabilityError(
+            "tx.writeNodeUpsertBatch()",
+            "exact-session heterogeneous node upsert program",
+            { dialect: target.dialect }
+          );
+        }
+        return upsert({
+          entries: validated,
+          schemaFence: {
+            graphId: this.graphId,
+            expectedVersion: schemaVersion
+          }
+        });
+      }
+    );
+    if (rows.length !== validated.length) {
+      await diagnoseFusedSchemaFenceNoRow(
+        { graphId: this.graphId, schemaVersion },
+        txBackend
+      );
+      throw new ConfigurationError(
+        "writeNodeUpsertBatch did not observe its active schema fence.",
+        { code: "HETEROGENEOUS_NODE_BATCH_STALE_SCHEMA" }
+      );
+    }
+    for (const row of rows) receiptRecorder?.recordNode(row.kind, 1);
+    return rows.map(
+      (row) => rowToNode(row)
+    );
+  }
   /**
    * Builds the transaction context bound to a transaction-scoped backend.
    * Collections, fluent queries, and set-oriented reads all use that same
@@ -28761,6 +28940,7 @@ var StoreImplementation = class _StoreImplementation {
     const base = {
       nodes,
       edges,
+      writeNodeUpsertBatch: (entries) => this.#writeNodeUpsertBatch(txBackend, entries, receiptRecorder),
       ...this.#createTransactionReadSurface(txBackend, attempt),
       ...receiptIdentity === void 0 ? {} : { identity: receiptIdentity },
       backend: createTransactionReadBackend(txBackend),
@@ -31011,5 +31191,5 @@ async function createVerifiedAdapterStore(graph, backend, options) {
 }
 
 export { CURRENT_ONLY_READ_NAMES, EDGE_TEMPORAL_READ_NAMES, ExecutableAggregateQuery, ExecutableProjectionQuery, ExecutableQuery, ExecutableRelationQuery, IDENTITY_READ_NAMES, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, NODE_TEMPORAL_READ_NAMES, PreparedQuery, QueryBuilder, RecordedStoreView, StoreAnalysisCursorStaleError, 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-MIBWA6HX.js.map
-//# sourceMappingURL=chunk-MIBWA6HX.js.map
+//# sourceMappingURL=chunk-TR7QTODF.js.map
+//# sourceMappingURL=chunk-TR7QTODF.js.map