@sixb/core 0.1.15 → 0.1.17

package/dist/{chunk-fjw417jf.js → chunk-5yd8cchh.js}

@@ -15,16 +15,21 @@ import {
   paginate,
   InMemoryAuthStorage2,
   principalsEqual2
-} from "./chunk-qne45xqq.js";
+} from "./chunk-svabwqdq.js";
 import {
   ObjectReadLimitExceededError2,
   snapshotObjectReadExecutionLimits2,
   assertObjectReadFacetCount2,
   assertObjectReadOutputWithinLimit2
-} from "./chunk-8fjmqjyx.js";
+} from "./chunk-5be2ath4.js";
 import {
   assertObjectReaderProject2
 } from "./chunk-v4jbb3rs.js";
+import {
+  queryScalarKindForSchema,
+  resolvePropertyQueryCapabilities2,
+  resolveQuerySchema
+} from "./chunk-rpxz486p.js";
 import {
   AgentStorageError2,
   transitionAgentThreadSandbox2,
@@ -48,10 +53,11 @@ import {
   buildAiModelCallGroups,
   normalizeAiModelCallCostRecord2,
   aiModelCallCostMatchesUsage2
-} from "./chunk-xnx96gfy.js";
+} from "./chunk-ere85b8y.js";
 import {
   AiLimitStorageError2,
   aiLimitCalendarMonth2,
+  aiLimitMeterApplies2,
   AiLimitOperationLock2,
   aiLimitSubjectKey2,
   normalizeAiLimitAmount2,
@@ -73,42 +79,63 @@ import {
   cloneAiLimitPolicy2,
   assertNonBlank2,
   cloneValidDate2
-} from "./chunk-jgwb25gc.js";
+} from "./chunk-4as3wt1c.js";
 import {
   isAbandonedFileUploadSession,
   shouldDeleteFileUploadSession
 } from "./chunk-h89wz928.js";
 import {
   DurableFileUploadSessions2
-} from "./chunk-p0nbkys4.js";
+} from "./chunk-33saed7g.js";
 import {
   ExecutionStorageError2,
   prepareExecutionRecord2,
   cloneExecutionRecord
 } from "./chunk-tw03bsmb.js";
 import {
+  objectRefKey2,
+  linkRefKey2,
+  projectionEntityKey2,
+  telemetryPointKey2,
+  objectRefSortKey2,
+  linkRefSortKey2,
+  linkScopeKey,
+  linkScopeSortKey2,
+  telemetryPointSortKey2,
   sha256Canonical2,
-  createEventId2,
+  createEventId2
+} from "./chunk-b9affek3.js";
+import {
+  assertNonblank2,
+  assertPositiveInteger2,
   assertTimestamp2,
   invalidCorrelation2,
+  assertMaterializationHeader2,
   assertPageRows2,
   materializationChunkRows2,
-  materializationPlanItems2,
-  assertWorkRecord2,
+  materializationPlanChunk2,
+  materializationOutboxWrite2,
+  claimedOutboxRows2,
+  assertReplacementPlanCommit2,
+  prepareReplacementIdentities2,
+  projectionChangeCounts,
+  createCardinalityValidator2,
   workUniquenessKey2,
   comparePlanWork2,
   compareCardinalityWork2,
   compareEventWork2,
-  assertPlanChunkCorrelations2,
-  assertMaterializationHeader2,
   startScopeAccumulator2,
   appendScopeSnapshot2,
   finishScopeAccumulator2,
+  beginMaterializationVectorChanges2,
+  beginMaterializationApply2,
   ProviderMaterializationTransactionLifecycle2,
+  prepareMaterializationWork2,
   uniqueSorted2,
   assertExpectedObjectRevision2,
   assertExpectedLinkRevision2,
   assertExpectedLinkScopeRevision2,
+  duplicateMaterializationWork2,
   sourceStageRoots2,
   sourceMaterializationIdentity2,
   assertSourceBeginInput2,
@@ -119,18 +146,7 @@ import {
   assertSourceStagedRow2,
   isExactStagingManifest2,
   sourceConflict2
-} from "./chunk-g4rbm4a6.js";
-import {
-  objectRefKey2,
-  linkRefKey2,
-  projectionEntityKey2,
-  telemetryPointKey2,
-  objectRefSortKey2,
-  linkRefSortKey2,
-  linkScopeKey,
-  linkScopeSortKey2,
-  telemetryPointSortKey2
-} from "./chunk-7ytf06d3.js";
+} from "./chunk-wt4szfec.js";
 import {
   createStorageOperationScope2,
   createOperationScopedFacade2,
@@ -139,7 +155,7 @@ import {
   createOntologyOperationScope2,
   createObjectOperationScope2,
   createWorkflowRunOperationScope2
-} from "./chunk-mr60an99.js";
+} from "./chunk-qczk96d9.js";
 import {
   PipelineRunError2,
   assertPipelineRunExecution2
@@ -187,7 +203,7 @@ import {
   WorkflowRunError2,
   assertWorkflowRunExecution2,
   assertWorkflowAgentNodeRunExecution2
-} from "./chunk-xr7y35yj.js";
+} from "./chunk-t9shqx3w.js";
 import {
   ShareGrantStorageError2,
   normalizeShareGrantCreate2,
@@ -206,21 +222,22 @@ import {
   normalizeRevokeShareSessionInput2,
   cloneShareSessionRecord2
 } from "./chunk-z8fx5cgb.js";
+import {
+  ConnectorConnectionStorageError2,
+  CONNECTOR_CONNECTION_RUN_FAILURE_CODES2
+} from "./chunk-2c4j899j.js";
 import {
   actionSubjectsEqual2,
   actionRunPhaseRecordsEqual2,
   canRequeueActionRunAfterEnqueueFailure2,
   isTerminalActionRun2,
   StorageTransactionError2,
+  cloneFileDownloadGrantRecord,
   canRequeuePipelineRunAfterEnqueueFailure2,
   canRequeueSyncRunAfterEnqueueFailure2,
   createTransactionStorageProxy2,
   throwNestedStorageTransaction2
-} from "./chunk-zdkcdshk.js";
-import {
-  ConnectorConnectionStorageError2,
-  CONNECTOR_CONNECTION_RUN_FAILURE_CODES2
-} from "./chunk-2c4j899j.js";
+} from "./chunk-aq39q04r.js";
 import {
   assertPinnedDatasetWatermark2
 } from "./chunk-6aawea28.js";
@@ -1264,8 +1281,9 @@ class InMemoryAiLimitStorage2 {
       const unavailablePolicies = [];
       const unavailableReasons = new Set;
       for (const policy of enabledPolicies) {
-        if (!subjectKeys.has(aiLimitSubjectKey2(policy.subject)))
+        if (!subjectKeys.has(aiLimitSubjectKey2(policy.subject)) || !aiLimitMeterApplies2(policy.limit.meter, request.modelKind)) {
           continue;
+        }
         const limit = normalizeAiLimitAmount2(policy.limit);
         const estimate = estimates.get(aiLimitAmountKey2(limit));
         const status = await this.policyStatus(policy, request.period);
@@ -1301,7 +1319,7 @@ class InMemoryAiLimitStorage2 {
           resetAt: new Date(Math.min(...exhaustedPolicies.map((status) => status.period.resetAt.getTime())))
         };
       }
-      const buckets = aiLimitReservationBuckets2(enabledPolicies, request.subjects, request.estimates);
+      const buckets = aiLimitReservationBuckets2(enabledPolicies, request.subjects, request.estimates, request.modelKind);
       if (buckets.length === 0)
         return { status: "notRequired" };
       for (const bucket of buckets) {
@@ -1541,6 +1559,7 @@ class InMemoryAiLimitStorage2 {
       attempt: record.attempt,
       callId: record.callId,
       occurredAt: new Date(record.occurredAt),
+      ...record.modelKind === undefined ? {} : { modelKind: record.modelKind },
       ...record.usage.totalTokens === undefined ? {} : { totalTokens: record.usage.totalTokens },
       requesterGroupIds: [...record.requesterGroupIds],
       ...requester?.type === "user" || requester?.type === "serviceAccount" ? { requester: { type: requester.type, id: requester.id } } : {},
@@ -2561,6 +2580,50 @@ class InMemoryExecutionStorage {
   }
 }
 
+// src/storage/file-download-grants/in-memory.ts
+class InMemoryFileDownloadGrantStorage {
+  rows = new Map;
+  async create(record) {
+    const duplicate = [...this.rows.values()].some((current) => current.projectId === record.projectId && (current.id === record.id || current.tokenHash === record.tokenHash));
+    if (duplicate) {
+      throw new Error(`[Sixb] File download grant '${record.id}' conflicts with an existing one.`);
+    }
+    this.rows.set(rowKey(record.projectId, record.id), cloneFileDownloadGrantRecord(record));
+  }
+  async findByTokenHash(input) {
+    for (const record of this.rows.values()) {
+      if (record.projectId === input.projectId && record.tokenHash === input.tokenHash) {
+        return cloneFileDownloadGrantRecord(record);
+      }
+    }
+    return null;
+  }
+  async revoke(input) {
+    const key = rowKey(input.projectId, input.id);
+    const current = this.rows.get(key);
+    if (!current)
+      return null;
+    if (!current.revokedAt) {
+      this.rows.set(key, { ...current, revokedAt: new Date(input.revokedAt) });
+    }
+    return cloneFileDownloadGrantRecord(this.rows.get(key));
+  }
+  async deleteExpired(input) {
+    const expired = [...this.rows.entries()].filter(([, record]) => record.projectId === input.projectId && record.expiresAt.getTime() < input.expiredBefore.getTime()).slice(0, input.limit);
+    for (const [key] of expired)
+      this.rows.delete(key);
+    return expired.length;
+  }
+  snapshot() {
+    return new Map([...this.rows].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)]));
+  }
+  restore(snapshot) {
+    this.rows = new Map([...snapshot].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)]));
+  }
+}
+function rowKey(projectId, id) {
+  return `${projectId}\x00${id}`;
+}
 // src/objects/vectors/query.ts
 function hasVectorProfile2(query) {
   if (query.kind === "vector")
@@ -2572,12 +2635,27 @@ function hasVectorProfile2(query) {
 function isVectorProfileQuery2(query) {
   if (query.kind === "limit" || query.kind === "project")
     return isVectorProfileQuery2(query.input);
+  if (query.kind === "rerank") {
+    return query.input.kind === "vector" && isVectorProfileQuery2(query.input);
+  }
   if (query.kind !== "vector" || !query.profile)
     return false;
-  let input = query.input;
-  while (input.kind === "filter")
-    input = input.input;
-  return input.kind === "start" && !input.includeSubtypes;
+  return isVectorCandidateQuery(query.input);
+}
+function isVectorCandidateQuery(query) {
+  switch (query.kind) {
+    case "start":
+      return !query.includeSubtypes;
+    case "refs":
+      return true;
+    case "filter":
+    case "traverse":
+      return isVectorCandidateQuery(query.input);
+    case "set":
+      return query.inputs.every(isVectorCandidateQuery);
+    default:
+      return false;
+  }
 }
 
 // src/storage/objects/keys.ts
@@ -2743,6 +2821,7 @@ function vectorConfiguration(profile) {
     model: profile.model.modelId,
     representation: profile.model.definition.representation ?? { name: profile.model.modelId },
     dimensions: profile.model.definition.dimensions,
+    ...profile.model.definition.inputMode === "asymmetric" ? { inputMode: "asymmetric" } : {},
     metric: "cosine",
     precision: "float32",
     normalization: "l2-v1"
@@ -2850,6 +2929,8 @@ function assertLinkQueryLimit(limit) {
 }
 function evaluateObjectQuery(query, source) {
   switch (query.kind) {
+    case "rerank":
+      throw new Error("[Sixb] Reranking must execute in the model runtime, not storage.");
     case "start":
       return evaluateStart(query.objectTypeId, source);
     case "refs":
@@ -3521,6 +3602,7 @@ function createInMemorySelectedReader(source, params, queryCapabilities) {
       const universe = resolveSelectedReadUniverse(source, plan, limits);
       const result = evaluateObjectQuery(stripOuterRowShape(input.query), universe);
       return visible(structuredClone({
+        total: result.entries.length,
         facets: buildFacetResults(result.entries.map((entry) => entry.row), input.facets)
       }));
     },
@@ -3759,6 +3841,7 @@ class InMemoryObjectStorage {
   async facetObjects(params) {
     const result = evaluateObjectQuery(stripOuterRowShape(params.query), this.readSource(params.projectId));
     return {
+      total: result.entries.length,
       facets: buildFacetResults(result.entries.map((entry) => entry.row), params.facets)
     };
   }
@@ -3945,7 +4028,9 @@ function createInMemoryOntologyState() {
     objectOverrides: new Map,
     linkOverrides: new Map,
     linkSlotOverrides: new Map,
-    outbox: new Map
+    outbox: new Map,
+    replacementPlans: new Map,
+    commitTouches: new Map
   };
 }
 function projectEntityKey(projectId, entityKey) {
@@ -4333,55 +4418,8 @@ function storedSourceLink(sourceId, materializationId, row) {
     return null;
   return storedSource(sourceId, materializationId, row);
 }
-function addReplacementLink(replacement, ref, diffRequired) {
-  const key = linkRefKey2(ref);
-  const existing = replacement.links.get(key);
-  if (existing) {
-    existing.diffRequired ||= diffRequired;
-    if (diffRequired)
-      replacement.affectedScopes.add(linkScopeSortKey2(ref.source, ref.linkId));
-    return;
-  }
-  replacement.links.set(key, {
-    ref: structuredClone(ref),
-    sortKey: linkRefSortKey2(ref),
-    diffRequired
-  });
-  if (diffRequired)
-    replacement.affectedScopes.add(linkScopeSortKey2(ref.source, ref.linkId));
-}
 
 // src/storage/ontology/in-memory/materializations-work.ts
-function assertChunkSequence(session, chunk) {
-  const planItems = materializationPlanItems2(chunk);
-  const applyStream = session.workStreams.apply;
-  const appliedStart = session.appliedPlanItems.length;
-  if (planItems.length > 0 && (!applyStream.started || appliedStart + planItems.length > applyStream.emittedCount)) {
-    invalidCorrelation2("Materialization plan items cannot be applied before they are streamed.");
-  }
-  for (let offset = 0;offset < planItems.length; offset += 1) {
-    const expected = session.applyWork[appliedStart + offset]?.item;
-    if (!expected || stableJsonStringify2(planItems[offset]) !== stableJsonStringify2(expected)) {
-      invalidCorrelation2("Materialization plan items must be applied in exact streamed order.");
-    }
-  }
-  const eventStream = session.workStreams.event;
-  const appliedOutboxCount = session.outboxEnvelopes.size;
-  if (chunk.outbox.length > 0 && (!eventStream.started || appliedOutboxCount + chunk.outbox.length > eventStream.emittedCount)) {
-    invalidCorrelation2("Materialization events cannot be applied before they are streamed.");
-  }
-  for (let offset = 0;offset < chunk.outbox.length; offset += 1) {
-    const expected = session.eventWork[appliedOutboxCount + offset];
-    const actual = chunk.outbox[offset]?.envelope;
-    if (!expected || !actual) {
-      invalidCorrelation2("Materialization outbox events must follow exact streamed order.");
-    }
-    const { id: _id, commitOrdinal, ...actualDraft } = actual;
-    if (commitOrdinal !== appliedOutboxCount + offset || stableJsonStringify2(actualDraft) !== stableJsonStringify2(expected.draft)) {
-      invalidCorrelation2("Materialization outbox events must follow exact streamed order.");
-    }
-  }
-}
 function assertLastCommit(value, expected, label) {
   if ((value?.lastCommitId ?? null) !== expected) {
     throw new MaterializationConflictError2("effective-state", `Expected ${label} changed.`);
@@ -4392,11 +4430,11 @@ function assertLastCommit(value, expected, label) {
 function assertFinalizationCorrelations(session, finalization, state, objects) {
   const { commit } = session.header;
   const { result, sourceActivations } = finalization;
-  if (result.commitId !== commit.id || result.kind !== commit.intent.kind || result.committedAt !== commit.committedAt || result.created !== true || !Number.isSafeInteger(result.eventCount) || result.eventCount < 0 || result.eventCount !== session.outboxEnvelopes.size) {
+  if (result.commitId !== commit.id || result.kind !== commit.intent.kind || result.committedAt !== commit.committedAt || result.created !== true || !Number.isSafeInteger(result.eventCount) || result.eventCount < 0 || result.eventCount !== session.outboxWrites.size) {
     invalidCorrelation2("Materialization result does not correlate with its commit intent.");
   }
   for (let ordinal = 0;ordinal < result.eventCount; ordinal += 1) {
-    if (!session.outboxEnvelopes.has(ordinal)) {
+    if (!session.outboxWrites.has(ordinal)) {
       invalidCorrelation2("Outbox event ordinals must be contiguous from zero.");
     }
   }
@@ -4418,7 +4456,7 @@ function assertFinalizationCorrelations(session, finalization, state, objects) {
     assertSourceActivationCorrelation(activation, session, state);
   }
   if (sourceActivations[0]) {
-    assertReplacementFullyStreamed(session, sourceActivations[0]);
+    assertPlanCoverage(session, sourceActivations[0]);
   }
   assertFinalizedWork(session, state, objects);
   if (commit.intent.kind === "projection") {
@@ -4558,16 +4596,8 @@ function assertSourceDatasetWatermark(active, next) {
   assertPinnedDatasetWatermark2(active, next, "Source activation");
 }
 function assertFinalizedWork(session, state, objects) {
-  const expectedPlanItems = session.applyWork.map((record) => stableJsonStringify2(record.item));
-  const appliedPlanItems = session.appliedPlanItems;
-  if (expectedPlanItems.length > 0 && !session.workStreams.apply.completed) {
-    invalidCorrelation2("Materialization plan work was not fully streamed.");
-  }
-  if (stableJsonStringify2(appliedPlanItems) !== stableJsonStringify2(expectedPlanItems)) {
-    invalidCorrelation2("Materialization plan work was not applied exactly once.");
-  }
-  if (session.cardinalityWork.length > 0 && !session.workStreams.cardinality.completed) {
-    invalidCorrelation2("Materialization cardinality work was not fully validated.");
+  if (!session.applied) {
+    invalidCorrelation2("A materialization plan must apply before it finalizes.");
   }
   assertFinalCardinality(session.cardinalityWork, session.header.commit.projectId, objects);
   if (session.header.commit.intent.kind === "telemetry") {
@@ -4577,24 +4607,20 @@ function assertFinalizedWork(session, state, objects) {
     }
   }
   const expectedEvents = [...session.eventWork].sort(compareEventWork2);
-  if (expectedEvents.length > 0 && !session.workStreams.event.completed) {
-    invalidCorrelation2("Materialization event work was not fully drained.");
-  }
-  if (session.outboxEnvelopes.size !== expectedEvents.length) {
+  if (session.outboxWrites.size !== expectedEvents.length) {
     invalidCorrelation2("Materialization event work was not fully written to the outbox.");
   }
   for (let ordinal = 0;ordinal < expectedEvents.length; ordinal += 1) {
     const expected = expectedEvents[ordinal];
-    const actual = session.outboxEnvelopes.get(ordinal);
+    const actual = session.outboxWrites.get(ordinal);
     if (!expected || !actual) {
       invalidCorrelation2("Materialization event work was not fully written to the outbox.");
     }
-    const { id, commitOrdinal, ...actualDraft } = actual;
-    if (commitOrdinal !== ordinal || id !== createEventId2(session.header.commit.projectId, session.header.commit.id, ordinal) || stableJsonStringify2(actualDraft) !== stableJsonStringify2(expected.draft)) {
+    if (actual.commitOrdinal !== ordinal || actual.id !== createEventId2(session.header.commit.projectId, session.header.commit.id, ordinal) || stableJsonStringify2(actual.event) !== stableJsonStringify2(expected.draft)) {
       invalidCorrelation2("Materialization outbox event does not match its staged event work.");
     }
     const persisted = state.outbox.get(outboxKey(session.header.commit.projectId, actual.id));
-    if (!persisted || stableJsonStringify2(persisted.envelope) !== stableJsonStringify2(actual)) {
+    if (!persisted || stableJsonStringify2(persisted.event) !== stableJsonStringify2(actual.event)) {
       invalidCorrelation2("Materialization outbox event was not persisted.");
     }
   }
@@ -4602,26 +4628,15 @@ function assertFinalizedWork(session, state, objects) {
 function assertFinalCardinality(records, projectId, objects) {
   const effectiveOccupants = records.filter((record) => record.view === "effective");
   const scopes = new Map;
-  let currentScope = null;
-  let occupiedCount = 0;
   for (const record of effectiveOccupants) {
-    if (record.scopeSortKey !== currentScope) {
-      currentScope = record.scopeSortKey;
-      occupiedCount = 0;
-    }
     const scope = scopes.get(record.scopeSortKey) ?? {
       source: structuredClone(record.ref.source),
       linkId: record.ref.linkId,
       occupiedLinkKeys: new Set
     };
     scopes.set(record.scopeSortKey, scope);
-    if (record.occupied) {
-      occupiedCount += 1;
+    if (record.occupied)
       scope.occupiedLinkKeys.add(record.linkSortKey);
-      if (occupiedCount > 1) {
-        invalidCorrelation2("Materialization cardinality work violates cardinality-one.");
-      }
-    }
   }
   const adapter = getInMemoryObjectMaterializerAdapter(objects);
   for (const scope of scopes.values()) {
@@ -4634,21 +4649,14 @@ function assertFinalCardinality(records, projectId, objects) {
     }
   }
 }
-function assertReplacementFullyStreamed(session, activation) {
-  const replacement = session.replacement;
-  if (!replacement || replacement.sourceId !== activation.source.projectionId || replacement.candidateMaterializationId !== activation.materializationId || replacement.candidate.materializationId !== activation.materializationId || replacement.candidate.projectionKind !== activation.projectionKind || replacement.candidate.protocol !== activation.protocol) {
-    invalidCorrelation2("Source activation does not match the replacement candidate opened by the session.");
-  }
-  if (activation.projectionKind === "object" && (!replacement.objectStreamCompleted || !replacement.linkStreamCompleted)) {
-    invalidCorrelation2("Object projection replacement state was not fully streamed.");
-  }
-  if (activation.projectionKind === "link" && !replacement.linkStreamCompleted) {
-    invalidCorrelation2("Link projection replacement state was not fully streamed.");
+function assertPlanCoverage(session, activation) {
+  const plan = session.plan;
+  if (!plan || plan.sourceId !== activation.source.projectionId || plan.materializationId !== activation.materializationId || plan.projectionKind !== activation.projectionKind) {
+    invalidCorrelation2("Source activation does not match the replacement plan the session applies.");
   }
-  const expectedObjectKeys = activation.projectionKind === "object" ? [...replacement.objects.keys()].sort() : [];
-  const expectedLinkKeys = [...replacement.links.entries()].filter(([, value]) => value.diffRequired).map(([key]) => key).sort();
-  if (stableJsonStringify2(classificationKeys(session, "object")) !== stableJsonStringify2(expectedObjectKeys) || stableJsonStringify2(classificationKeys(session, "link")) !== stableJsonStringify2(expectedLinkKeys) || classificationKeys(session, "point").length > 0) {
-    invalidCorrelation2("Projection replacement classification coverage does not match its streamed state.");
+  const expected = (kind) => [...plan.identities.values()].filter((identity) => identity.entity.kind === kind && identity.diffRequired).map((identity) => identity.entity.kind === "object" ? objectRefKey2(identity.entity.ref) : linkRefKey2(identity.entity.ref)).sort();
+  if (stableJsonStringify2(classificationKeys(session, "object")) !== stableJsonStringify2(expected("object")) || stableJsonStringify2(classificationKeys(session, "link")) !== stableJsonStringify2(expected("link")) || classificationKeys(session, "point").length > 0) {
+    invalidCorrelation2("Projection replacement classification coverage does not match its plan.");
   }
 }
 function classificationKeys(session, entityKind) {
@@ -4675,7 +4683,7 @@ function* previousSourceRows(state, candidate) {
     }
   }
 }
-function activateSourceRoots(state, candidate, activation) {
+function activateSourceRoots(state, candidate, activation, touches) {
   if (candidate.base && (candidate.base.materializationId !== activation.expected.activeMaterializationId || candidate.base.lastCommitId !== activation.expected.lastCommitId)) {
     throw new MaterializationConflictError2("projection-fence", "Source delta base changed before activation.");
   }
@@ -4698,6 +4706,7 @@ function activateSourceRoots(state, candidate, activation) {
       if (sources.size === 0)
         state.activeSourceRows.delete(indexKey);
       if (row.assertion.kind === "link") {
+        touches.links.add(linkRefKey2(row.assertion.ref));
         const scopeKey = projectEntityKey(candidate.projectId, linkScopeSortKey2(row.assertion.ref.source, row.assertion.ref.linkId));
         const scope = state.activeSourceLinkScopes.get(scopeKey);
         scope.delete(JSON.stringify([candidate.source.projectionId, entityKey]));
@@ -4723,6 +4732,7 @@ function activateSourceRoots(state, candidate, activation) {
       sources.set(candidate.source.projectionId, row);
       state.activeSourceRows.set(indexKey, sources);
       if (row.assertion.kind === "link") {
+        touches.links.add(linkRefKey2(row.assertion.ref));
         const scopeKey = projectEntityKey(candidate.projectId, linkScopeSortKey2(row.assertion.ref.source, row.assertion.ref.linkId));
         const scope = state.activeSourceLinkScopes.get(scopeKey) ?? new Map;
         scope.set(JSON.stringify([candidate.source.projectionId, entityKey]), row);
@@ -4734,325 +4744,749 @@ function activateSourceRoots(state, candidate, activation) {
   state.activeSourceHeads.set(sourceKey, candidate.materializationId);
 }
 
-// src/storage/ontology/in-memory/materializations.ts
-class InMemoryOntologyMaterializationStorage {
+// src/storage/ontology/in-memory/replacement-plans.ts
+function emptyCommitTouches(projectId) {
+  return { projectId, objects: new Set, links: new Set, scopes: new Set };
+}
+function touchPlanItem(touches, item) {
+  switch (item.kind) {
+    case "object-override-upsert":
+    case "object-override-delete":
+    case "object-delete":
+      touches.objects.add(objectRefKey2(item.value.ref));
+      return;
+    case "object-upsert":
+      touches.objects.add(objectRefKey2(item.value.row.ref));
+      return;
+    case "point-upsert":
+      touches.objects.add(objectRefKey2(item.value.point.series.object));
+      return;
+    case "link-override-upsert":
+    case "link-override-delete":
+    case "link-delete":
+      touches.links.add(linkRefKey2(item.value.ref));
+      return;
+    case "link-upsert":
+      touches.links.add(linkRefKey2(item.value.row.ref));
+      return;
+    case "link-slot-override-upsert":
+    case "link-slot-override-delete":
+      touches.scopes.add(linkScopeKey(item.value.ref.source, item.value.ref.linkId));
+      return;
+  }
+}
+function replacementPlanKey(input) {
+  return sourceMaterializationKey(input.projectId, input.source.projectionId, input.materializationId);
+}
+
+class InMemoryOntologyReplacementPlanStorage {
   state;
   objects;
-  timeseries;
-  getTransactionToken;
-  getMaterializationLifecycle;
-  executionExists;
+  reader;
+  runRootOperation;
+  assertExecution;
   hooks;
-  sessions = new WeakMap;
-  liveSessions = new Set;
-  constructor(state, objects, timeseries, getTransactionToken, getMaterializationLifecycle, executionExists, hooks = {}) {
+  constructor(state, objects, reader, runRootOperation, assertExecution, hooks = {}) {
     this.state = state;
     this.objects = objects;
-    this.timeseries = timeseries;
-    this.getTransactionToken = getTransactionToken;
-    this.getMaterializationLifecycle = getMaterializationLifecycle;
-    this.executionExists = executionExists;
+    this.reader = reader;
+    this.runRootOperation = runRootOperation;
+    this.assertExecution = assertExecution;
     this.hooks = hooks;
   }
-  async begin(input) {
-    const transactionToken = this.getTransactionToken();
-    const lifecycle = this.getMaterializationLifecycle();
-    if (!transactionToken || !lifecycle) {
-      throw new MaterializationValidationError2("Materialization sessions require an active storage transaction.");
-    }
-    assertMaterializationHeader2(input);
-    if (!await this.executionExists(input.commit.projectId, input.commit.executionId)) {
-      throw new MaterializationValidationError2(`Ontology commit execution '${input.commit.executionId}' does not exist in project '${input.commit.projectId}'.`);
-    }
-    this.assertCommitAbsent(input);
-    for (const expected of input.expected.sources)
-      this.assertSource(expected, input.commit.projectId);
-    for (const expected of input.expected.objects)
-      await this.assertObject(expected, input.commit.projectId);
-    for (const expected of input.expected.links)
-      await this.assertLink(expected, input.commit.projectId);
-    const expectedScopeRevisions = new Map;
-    for (const expected of input.expected.linkScopes) {
-      const key = linkScopeSortKey2(expected.source, expected.linkId);
-      const current = expectedScopeRevisions.get(key) ?? this.computeEffectiveLinkScope(input.commit.projectId, expected.source, expected.linkId);
-      expectedScopeRevisions.set(key, current);
-      assertExpectedLinkScopeRevision2(current.fingerprint, expected);
-    }
-    for (const expected of input.expected.points)
-      this.assertPoint(expected, input.commit.projectId);
-    const providerToken = {};
-    const session = {
-      providerToken,
-      header: structuredClone(input),
-      transactionToken,
-      lifecycle,
-      active: true,
-      writeOrdinal: 0,
-      work: new Map,
-      workUniqueKeys: new Set,
-      applyWork: [],
-      cardinalityWork: [],
-      eventWork: [],
-      appliedPlanItems: [],
-      outboxEnvelopes: new Map,
-      workStreams: {
-        apply: { started: false, completed: false, emittedCount: 0 },
-        cardinality: { started: false, completed: false, emittedCount: 0 },
-        event: { started: false, completed: false, emittedCount: 0 }
-      },
-      workSealed: false,
-      incidentLinksByObject: null,
-      linkSlotStates: new Map,
-      objectExistence: new Map,
-      replacement: null
-    };
-    this.sessions.set(providerToken, session);
-    this.liveSessions.add(session);
-    lifecycle.register(providerToken);
-    return { providerToken };
-  }
-  deactivateTransaction(transactionToken) {
-    for (const session of this.liveSessions) {
-      if (session.transactionToken !== transactionToken)
-        continue;
-      this.releaseSession(session);
-    }
-  }
-  releaseSession(session) {
-    session.active = false;
-    session.work.clear();
-    session.workUniqueKeys.clear();
-    session.applyWork.length = 0;
-    session.cardinalityWork.length = 0;
-    session.eventWork.length = 0;
-    session.appliedPlanItems.length = 0;
-    session.outboxEnvelopes.clear();
-    session.incidentLinksByObject = null;
-    session.linkSlotStates = null;
-    session.objectExistence.clear();
-    session.replacement = null;
-    this.liveSessions.delete(session);
-    session.lifecycle.complete(session.providerToken);
-  }
-  async* streamState(input) {
-    const session = this.requireSession(input.session);
-    assertPageRows2(input.pageRows);
-    for await (const request of input.requests) {
-      this.requireSession(input.session);
-      this.hooks.beforeRead?.("state.read");
-      const objectRefs = uniqueSorted2(request.objects, objectRefKey2, objectRefSortKey2);
-      for (let offset = 0;offset < objectRefs.length; offset += input.pageRows) {
-        this.requireSession(input.session);
-        const objects = [];
-        for (const ref of objectRefs.slice(offset, offset + input.pageRows)) {
-          objects.push(await this.objectState(session, ref));
-        }
-        this.requireSession(input.session);
-        this.hooks.observeBuffer?.("state.object.page", objects.length);
-        yield { objects, links: [], linkScopes: [], points: [] };
-      }
-      const linkRefs = uniqueSorted2(request.links, linkRefKey2, linkRefSortKey2);
-      for (let offset = 0;offset < linkRefs.length; offset += input.pageRows) {
-        this.requireSession(input.session);
-        const links = [];
-        for (const ref of linkRefs.slice(offset, offset + input.pageRows)) {
-          links.push(await this.linkState(session, ref));
-        }
-        this.requireSession(input.session);
-        this.hooks.observeBuffer?.("state.link.page", links.length);
-        yield { objects: [], links, linkScopes: [], points: [] };
-      }
-      const incidentRefs = this.incidentLinkRefs(session, request.incidentObjects);
-      for (let offset = 0;offset < incidentRefs.length; offset += input.pageRows) {
-        this.requireSession(input.session);
-        const refs = incidentRefs.slice(offset, offset + input.pageRows);
-        const links = [];
-        for (const ref of refs)
-          links.push(await this.linkState(session, ref));
-        this.requireSession(input.session);
-        this.hooks.observeBuffer?.("state.incident-link.page", links.length);
-        yield { objects: [], links, linkScopes: [], points: [] };
-      }
-      for (const scope of uniqueBy(request.linkScopes, (value) => linkScopeSortKey2(value.source, value.linkId))) {
-        this.requireSession(input.session);
-        const value = this.linkSlotState(session, scope.source, scope.linkId);
-        yield { objects: [], links: [], linkScopes: [value], points: [] };
+  async open(input) {
+    return this.runRootOperation(async () => {
+      assertReplacementPlanCommit2(input.commit);
+      const candidate = await this.requireCandidate(input);
+      const key = replacementPlanKey(input);
+      const active = findActiveSourceMaterialization(this.state, input.projectId, input.source.projectionId);
+      const replacedMaterializationId = active?.materializationId ?? null;
+      const replacedLastCommitId = active?.lastCommitId ?? null;
+      const existing = this.state.replacementPlans.get(key);
+      if (existing?.replacedMaterializationId === replacedMaterializationId && existing.replacedLastCommitId === replacedLastCommitId) {
+        return { committedAt: existing.committedAt };
       }
-      const requestedPoints = uniqueSorted2(request.points, (point) => telemetryPointKey2(point.series, point.at), (point) => telemetryPointSortKey2(point.series, point.at));
-      for (let offset = 0;offset < requestedPoints.length; offset += input.pageRows) {
-        this.requireSession(input.session);
-        const points = [];
-        for (const point of requestedPoints.slice(offset, offset + input.pageRows)) {
-          const stored = getInMemoryTimeseriesMaterializerAdapter(this.timeseries).getExactPoint(session.header.commit.projectId, point.series, point.at);
-          if (stored)
-            points.push(storedPoint(stored));
+      const plan = {
+        projectId: input.projectId,
+        sourceId: input.source.projectionId,
+        materializationId: input.materializationId,
+        projectionKind: candidate.projectionKind,
+        commitId: input.commit.id,
+        committedAt: input.commit.committedAt,
+        replacedMaterializationId,
+        replacedLastCommitId,
+        watermark: this.state.commitsById.size,
+        owned: new Set,
+        identities: new Map,
+        workKeys: new Set
+      };
+      for (const rows of [
+        previousSourceRows(this.state, candidate),
+        candidate.rowsByEntity.values()
+      ]) {
+        for (const row of rows) {
+          plan.owned.add(projectionEntityKey2(row.assertion));
+          addIdentity(plan, row.assertion, true);
         }
-        this.requireSession(input.session);
-        this.hooks.observeBuffer?.("state.point.page", points.length);
-        if (points.length > 0)
-          yield { objects: [], links: [], linkScopes: [], points };
       }
-    }
+      this.state.replacementPlans.set(key, plan);
+      return { committedAt: plan.committedAt };
+    });
   }
-  async* streamSourceReplacementState(input) {
-    const session = this.requireSession(input.session);
+  async* streamState(input) {
     assertPageRows2(input.pageRows);
-    const replacement = this.requireReplacement(session, input);
-    if (input.entityKind === "object") {
-      if (replacement.candidate.projectionKind !== "object") {
+    this.hooks.beforeRead?.(`replacement-plan.${input.entityKind}`);
+    const pending = await this.runRootOperation(async () => {
+      const { plan } = await this.requirePlan(input);
+      if (input.entityKind === "object" && plan.projectionKind !== "object") {
         throw new MaterializationConflictError2("source-materialization", "Link projection replacement cannot stream object state.");
       }
-      if (replacement.objectStreamStarted)
-        throw new MaterializationConflictError2("effective-state", "Replacement object state may only be streamed once per session.");
-      replacement.objectStreamStarted = true;
-      this.hooks.beforeRead?.("source-replacement.object");
-      for (let offset = 0;offset < replacement.orderedObjects.length; offset += input.pageRows) {
-        this.requireSession(input.session);
-        const selected = replacement.orderedObjects.slice(offset, offset + input.pageRows);
-        const objects = [];
-        for (const entry of selected) {
-          const key = projectionEntityKey2({ kind: "object", ref: entry.ref });
-          const base = await this.objectState(session, entry.ref);
-          objects.push({
-            ref: base.ref,
-            candidateSource: storedSourceObject(input.source.projectionId, replacement.candidate.materializationId, replacement.candidate.rowsByEntity.get(key)),
-            override: base.override,
-            effective: base.effective,
-            latestTelemetry: base.latestTelemetry
-          });
+      if (input.entityKind === "link") {
+        if (unplanned(plan, "object").length > 0) {
+          throw new MaterializationConflictError2("effective-state", "Object projection replacement must plan every object before its links.");
         }
-        this.requireSession(input.session);
-        this.hooks.observeBuffer?.("replacement.object.page", objects.length);
-        yield { objects, links: [] };
+        this.expandLinks(plan);
       }
-      this.requireSession(input.session);
-      replacement.objectStreamCompleted = true;
-      return;
-    }
-    if (replacement.candidate.projectionKind === "object" && !replacement.objectStreamCompleted) {
-      throw new MaterializationConflictError2("effective-state", "Object projection replacement must fully stream object state before link state.");
-    }
-    if (replacement.linkStreamStarted)
-      throw new MaterializationConflictError2("effective-state", "Replacement link state may only be streamed once per session.");
-    replacement.linkStreamStarted = true;
-    this.hooks.beforeRead?.("source-replacement.link");
-    this.expandReplacementLinks(session, replacement);
-    replacement.orderedLinks ??= [...replacement.links.values()].sort((left, right) => left.sortKey.localeCompare(right.sortKey));
-    for (let offset = 0;offset < replacement.orderedLinks.length; offset += input.pageRows) {
-      this.requireSession(input.session);
-      const selected = replacement.orderedLinks.slice(offset, offset + input.pageRows);
-      const links = [];
-      for (const entry of selected) {
-        const key = projectionEntityKey2({ kind: "link", ref: entry.ref });
-        const base = await this.linkState(session, entry.ref);
-        const ownedByReplacement = replacement.owned.has(key);
-        links.push({
-          ref: base.ref,
-          candidateSource: ownedByReplacement ? storedSourceLink(input.source.projectionId, replacement.candidate.materializationId, replacement.candidate.rowsByEntity.get(key)) : base.source,
-          override: base.override,
-          slotOverride: base.slotOverride,
-          effective: base.effective,
-          diffRequired: entry.diffRequired
+      return unplanned(plan, input.entityKind).map((identity) => projectionEntityKey2(identity.entity));
+    });
+    for (let offset = 0;offset < pending.length; offset += input.pageRows) {
+      const keys = pending.slice(offset, offset + input.pageRows);
+      const page = await this.runRootOperation(async () => {
+        const { plan, candidate } = await this.requirePlan(input);
+        const selected = keys.flatMap((key) => {
+          const identity = plan.identities.get(key);
+          return identity?.plannedRevision === null ? [identity] : [];
         });
-      }
-      this.requireSession(input.session);
-      this.hooks.observeBuffer?.("replacement.link.page", links.length);
-      yield { objects: [], links };
+        if (selected.length === 0)
+          return null;
+        return input.entityKind === "object" ? this.objectPage(plan, candidate, selected) : this.linkPage(plan, candidate, selected);
+      });
+      if (!page)
+        continue;
+      this.hooks.observeBuffer?.(`replacement.${input.entityKind}.page`, page.objects.length + page.links.length);
+      yield page;
     }
-    this.requireSession(input.session);
-    replacement.linkStreamCompleted = true;
   }
-  async stageWork(input) {
-    const session = this.requireSession(input.session);
-    if (session.workSealed) {
-      throw new MaterializationConflictError2("effective-state", "Materialization work cannot be staged after draining begins.");
-    }
-    const batchKeys = new Set;
-    const batchUniqueKeys = new Set;
-    for (const record of input.records) {
-      assertWorkRecord2(record, session.header);
-      const uniqueKey = workUniquenessKey2(record);
-      if (batchKeys.has(record.recordKey) || session.work.has(record.recordKey) || batchUniqueKeys.has(uniqueKey) || session.workUniqueKeys.has(uniqueKey)) {
-        throw new MaterializationConflictError2("effective-state", `Duplicate materialization work key '${record.recordKey}'.`);
-      }
-      if (record.kind === "incident-object" && (!session.replacement || session.replacement.linkStreamStarted)) {
-        throw new MaterializationConflictError2("effective-state", "Incident replacement work must be staged before link state is streamed.");
+  async stage(input) {
+    await this.runRootOperation(async () => {
+      const { plan } = await this.requirePlan(input);
+      const updates = prepareReplacementIdentities2(input, plan).map((prepared) => {
+        const current = plan.identities.get(prepared.entityKey);
+        if (!current || current.readRevision === null || current.plannedRevision !== null) {
+          throw new MaterializationValidationError2(`Replacement identity ${prepared.entityKey} is not streamed and still to plan.`);
+        }
+        return { current, records: structuredClone(prepared.records) };
+      });
+      const claimed = new Set;
+      for (const { records } of updates) {
+        for (const record of records) {
+          for (const key of workKeys(record)) {
+            if (claimed.has(key) || plan.workKeys.has(key)) {
+              throw duplicateMaterializationWork2(record.recordKey);
+            }
+            claimed.add(key);
+          }
+        }
       }
-      batchKeys.add(record.recordKey);
-      batchUniqueKeys.add(uniqueKey);
-    }
-    const cloned = input.records.map((record) => structuredClone(record));
-    this.hooks.observeWork?.(cloned);
-    for (const record of cloned) {
-      session.work.set(record.recordKey, record);
-      session.workUniqueKeys.add(workUniquenessKey2(record));
-      if (record.kind === "plan")
-        session.applyWork.push(record);
-      if (record.kind === "cardinality")
-        session.cardinalityWork.push(record);
-      if (record.kind === "event")
-        session.eventWork.push(record);
-      if (record.kind === "object-existence") {
-        session.objectExistence.set(objectRefKey2(record.ref), record);
+      const staged = updates.flatMap(({ records }) => records);
+      this.hooks.observeWork?.(staged);
+      for (const { current, records } of updates) {
+        current.records = records;
+        current.plannedRevision = current.readRevision;
       }
-      if (record.kind === "incident-object") {
-        const replacement = session.replacement;
-        if (replacement) {
-          replacement.incidentObjects.set(objectRefKey2(record.ref), record.ref);
-          replacement.linksExpanded = false;
-          replacement.orderedLinks = null;
+      for (const key of claimed)
+        plan.workKeys.add(key);
+      this.hooks.observeBuffer?.("plan.stage", updates.length);
+    });
+  }
+  async refresh(input) {
+    const { plan } = await this.requirePlan(input);
+    const pending = [...plan.identities.values()].filter((identity) => identity.plannedRevision === null);
+    if (pending.length > 0)
+      return { fresh: false, unplanned: pending.length };
+    let unplannedCount = 0;
+    if (this.state.commitsById.size !== plan.watermark) {
+      const touched = emptyCommitTouches(plan.projectId);
+      for (let ordinal = plan.watermark + 1;ordinal <= this.state.commitsById.size; ordinal += 1) {
+        const touches = this.state.commitTouches.get(ordinal);
+        if (touches?.projectId !== plan.projectId)
+          continue;
+        for (const kind of ["objects", "links", "scopes"]) {
+          for (const key of touches[kind])
+            touched[kind].add(key);
         }
       }
+      for (const identity of plan.identities.values()) {
+        if (!touchesIdentity(touched, identity.entity))
+          continue;
+        if (this.revision(plan, identity) === identity.plannedRevision)
+          continue;
+        unplan(plan, identity);
+        unplannedCount += 1;
+      }
+      unplannedCount += this.expandTouched(plan, touched);
+      plan.watermark = this.state.commitsById.size;
     }
-    this.hooks.observeBuffer?.("work.stage", cloned.length);
+    if (unplannedCount > 0)
+      return { fresh: false, unplanned: unplannedCount };
+    return {
+      fresh: true,
+      counts: projectionChangeCounts([...plan.identities.values()].flatMap((identity) => identity.records))
+    };
+  }
+  async purge(input) {
+    assertNonblank2(input.projectId, "Replacement plan purge project id");
+    assertPositiveInteger2(input.limit, "Replacement plan purge limit");
+    return this.runRootOperation(() => {
+      let horizon = this.state.commitsById.size;
+      for (const plan of this.state.replacementPlans.values()) {
+        if (plan.projectId === input.projectId)
+          horizon = Math.min(horizon, plan.watermark);
+      }
+      let deleted = 0;
+      for (const [ordinal, touches] of this.state.commitTouches) {
+        if (deleted === input.limit)
+          break;
+        if (ordinal > horizon || touches.projectId !== input.projectId)
+          continue;
+        this.state.commitTouches.delete(ordinal);
+        deleted += 1;
+      }
+      return deleted;
+    });
+  }
+  async objectPage(plan, candidate, selected) {
+    const objects = [];
+    for (const identity of selected) {
+      const ref = identity.entity.ref;
+      const base = await this.reader.objectState(plan.projectId, ref);
+      objects.push({
+        ref: base.ref,
+        candidateSource: storedSourceObject(plan.sourceId, plan.materializationId, candidate.rowsByEntity.get(projectionEntityKey2(identity.entity))),
+        override: base.override,
+        effective: base.effective,
+        latestTelemetry: base.latestTelemetry
+      });
+      identity.readRevision = this.revision(plan, identity);
+    }
+    return { objects, links: [], endpoints: [] };
+  }
+  async linkPage(plan, candidate, selected) {
+    const links = [];
+    const endpoints = new Map;
+    for (const identity of selected) {
+      const ref = identity.entity.ref;
+      const key = projectionEntityKey2(identity.entity);
+      const base = await this.reader.linkState(plan.projectId, ref);
+      links.push({
+        ref: base.ref,
+        candidateSource: plan.owned.has(key) ? storedSourceLink(plan.sourceId, plan.materializationId, candidate.rowsByEntity.get(key)) : base.source,
+        override: base.override,
+        slotOverride: base.slotOverride,
+        effective: base.effective,
+        diffRequired: identity.diffRequired
+      });
+      for (const endpoint of [ref.source, ref.target]) {
+        endpoints.set(objectRefKey2(endpoint), {
+          ref: structuredClone(endpoint),
+          exists: this.endpointExists(plan, endpoint)
+        });
+      }
+      identity.readRevision = this.revision(plan, identity);
+    }
+    return { objects: [], links, endpoints: [...endpoints.values()] };
+  }
+  endpointExists(plan, ref) {
+    const planned = plan.identities.get(projectionEntityKey2({ kind: "object", ref }));
+    const existence = planned?.records.find((record) => record.kind === "object-existence");
+    if (existence?.kind === "object-existence")
+      return existence.exists;
+    return getInMemoryObjectMaterializerAdapter(this.objects).getExactObjectRow(plan.projectId, ref.objectTypeId, ref.primaryId) !== null;
+  }
+  revision(plan, identity) {
+    if (identity.entity.kind === "object") {
+      return stableJsonStringify2(this.objectRevision(plan.projectId, identity.entity.ref));
+    }
+    const ref = identity.entity.ref;
+    const projectId = plan.projectId;
+    const row = getInMemoryObjectMaterializerAdapter(this.objects).getExactLinkRow(projectId, {
+      sourceTypeId: ref.source.objectTypeId,
+      sourceId: ref.source.primaryId,
+      linkId: ref.linkId,
+      targetTypeId: ref.target.objectTypeId,
+      targetId: ref.target.primaryId
+    });
+    const live = this.reader.findActiveLinkSource(projectId, ref);
+    return stableJsonStringify2([
+      row?.lastCommitId ?? null,
+      this.state.linkOverrides.get(projectEntityKey(projectId, linkRefKey2(ref)))?.lastCommitId ?? null,
+      this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(ref.source, ref.linkId)))?.lastCommitId ?? null,
+      live ? [live.source.projectionId, live.materializationId, live.stagingOrdinal] : null,
+      this.endpointRevision(plan, ref.source),
+      this.endpointRevision(plan, ref.target)
+    ]);
+  }
+  endpointRevision(plan, ref) {
+    if (plan.identities.has(projectionEntityKey2({ kind: "object", ref }))) {
+      return this.objectRevision(plan.projectId, ref);
+    }
+    return getInMemoryObjectMaterializerAdapter(this.objects).getExactObjectRow(plan.projectId, ref.objectTypeId, ref.primaryId) !== null;
+  }
+  objectRevision(projectId, ref) {
+    const row = getInMemoryObjectMaterializerAdapter(this.objects).getExactObjectRow(projectId, ref.objectTypeId, ref.primaryId);
+    return [
+      row ? [row.version, row.lastCommitId] : null,
+      this.state.objectOverrides.get(projectEntityKey(projectId, objectRefKey2(ref)))?.lastCommitId ?? null,
+      this.reader.latestTelemetry(projectId, ref).map((point) => [point.series.propertyId, point.at, point.lastCommitId])
+    ];
+  }
+  expandLinks(plan) {
+    const projectId = plan.projectId;
+    const incident = new Set;
+    for (const identity of plan.identities.values()) {
+      if (identity.entity.kind !== "object" || identity.expanded)
+        continue;
+      if (identity.plannedRevision === null)
+        continue;
+      identity.expanded = true;
+      for (const record of identity.records) {
+        if (record.kind === "incident-object")
+          incident.add(objectRefKey2(record.ref));
+      }
+    }
+    let added = 0;
+    const consider = (ref, diffRequired) => {
+      if (addIdentity(plan, { kind: "link", ref }, diffRequired))
+        added += 1;
+    };
+    if (incident.size > 0) {
+      const index = this.reader.incidentLinkIndex(projectId);
+      for (const key of incident) {
+        for (const ref of index.get(key) ?? [])
+          consider(ref, true);
+      }
+    }
+    const adapter = getInMemoryObjectMaterializerAdapter(this.objects);
+    const scopes = new Map;
+    for (const identity of plan.identities.values()) {
+      if (identity.entity.kind !== "link" || !identity.diffRequired || identity.expanded)
+        continue;
+      identity.expanded = true;
+      const ref = identity.entity.ref;
+      scopes.set(linkScopeSortKey2(ref.source, ref.linkId), ref);
+    }
+    for (const scope of scopes.values()) {
+      adapter.visitExactScopeLinks(projectId, scope.source.objectTypeId, scope.source.primaryId, scope.linkId, (row) => consider(linkRef(row), false));
+      const override = this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(scope.source, scope.linkId)));
+      if (override)
+        consider({ ...scope, target: override.value.target }, false);
+    }
+    return added;
+  }
+  expandTouched(plan, touched) {
+    const projectId = plan.projectId;
+    const incident = new Set;
+    const scopes = new Set;
+    for (const identity of plan.identities.values()) {
+      for (const record of identity.records) {
+        if (record.kind === "incident-object")
+          incident.add(objectRefKey2(record.ref));
+      }
+      if (identity.entity.kind === "link" && identity.diffRequired) {
+        scopes.add(linkScopeKey(identity.entity.ref.source, identity.entity.ref.linkId));
+      }
+    }
+    let added = 0;
+    const consider = (ref, member) => {
+      if (incident.has(objectRefKey2(ref.source)) || incident.has(objectRefKey2(ref.target))) {
+        if (addIdentity(plan, { kind: "link", ref }, true))
+          added += 1;
+      } else if (member && scopes.has(linkScopeKey(ref.source, ref.linkId))) {
+        if (addIdentity(plan, { kind: "link", ref }, false))
+          added += 1;
+      }
+    };
+    const adapter = getInMemoryObjectMaterializerAdapter(this.objects);
+    for (const key of touched.links) {
+      const ref = parseLinkKey(key);
+      const effective = adapter.getExactLinkRow(projectId, {
+        sourceTypeId: ref.source.objectTypeId,
+        sourceId: ref.source.primaryId,
+        linkId: ref.linkId,
+        targetTypeId: ref.target.objectTypeId,
+        targetId: ref.target.primaryId
+      }) !== null;
+      if (effective || this.state.linkOverrides.has(projectEntityKey(projectId, key)) || this.state.activeSourceRows.has(projectEntityKey(projectId, projectionEntityKey2({ kind: "link", ref })))) {
+        consider(ref, effective);
+      }
+    }
+    for (const key of touched.scopes) {
+      const override = this.state.linkSlotOverrides.get(projectEntityKey(projectId, key));
+      if (override)
+        consider({ ...override.ref, target: override.value.target }, true);
+    }
+    return added;
+  }
+  async requireCandidate(input) {
+    const candidate = this.state.sourceMaterializations.get(replacementPlanKey(input));
+    if (!candidate || candidate.status !== "ready" || candidate.projectionRunId !== input.execution.projectionRunId || candidate.executionToken !== input.execution.executionToken) {
+      throw new MaterializationConflictError2("source-materialization", `Candidate source materialization '${input.materializationId}' is missing, not ready, or owned by another execution.`);
+    }
+    await this.assertExecution({
+      projectId: input.projectId,
+      source: input.source,
+      execution: input.execution
+    });
+    return candidate;
+  }
+  async requirePlan(input) {
+    const candidate = await this.requireCandidate(input);
+    const plan = this.state.replacementPlans.get(replacementPlanKey(input));
+    if (!plan) {
+      throw new MaterializationConflictError2("source-materialization", `Candidate source materialization '${input.materializationId}' has no open plan.`);
+    }
+    return { plan, candidate };
+  }
+}
+function addIdentity(plan, entity, diffRequired) {
+  const key = projectionEntityKey2(entity);
+  const existing = plan.identities.get(key);
+  if (existing) {
+    if (!diffRequired || existing.diffRequired)
+      return false;
+    existing.diffRequired = true;
+    unplan(plan, existing);
+    return true;
+  }
+  plan.identities.set(key, {
+    entity: structuredClone({ kind: entity.kind, ref: entity.ref }),
+    sortKey: entity.kind === "object" ? objectRefSortKey2(entity.ref) : linkRefSortKey2(entity.ref),
+    diffRequired,
+    expanded: false,
+    readRevision: null,
+    plannedRevision: null,
+    records: []
+  });
+  return true;
+}
+function unplan(plan, identity) {
+  for (const record of identity.records) {
+    for (const key of workKeys(record))
+      plan.workKeys.delete(key);
+  }
+  identity.readRevision = null;
+  identity.plannedRevision = null;
+  identity.expanded = false;
+  identity.records = [];
+}
+function touchesIdentity(touched, entity) {
+  if (entity.kind === "object")
+    return touched.objects.has(objectRefKey2(entity.ref));
+  const { ref } = entity;
+  return touched.links.has(linkRefKey2(ref)) || touched.scopes.has(linkScopeKey(ref.source, ref.linkId)) || touched.objects.has(objectRefKey2(ref.source)) || touched.objects.has(objectRefKey2(ref.target));
+}
+function parseLinkKey(key) {
+  const [sourceTypeId, sourceId, linkId, targetTypeId, targetId] = JSON.parse(key);
+  return {
+    source: { objectTypeId: sourceTypeId, primaryId: sourceId },
+    linkId,
+    target: { objectTypeId: targetTypeId, primaryId: targetId }
+  };
+}
+function workKeys(record) {
+  return [`record:${record.recordKey}`, `unique:${workUniquenessKey2(record)}`];
+}
+function unplanned(plan, kind) {
+  return [...plan.identities.values()].filter((identity) => identity.entity.kind === kind && identity.plannedRevision === null).sort((left, right) => left.sortKey.localeCompare(right.sortKey));
+}
+
+// src/storage/ontology/in-memory/vectors.ts
+function vectorObjectKey(projectId, ref) {
+  return JSON.stringify([projectId, ref.objectTypeId, ref.primaryId]);
+}
+
+class InMemoryOntologyVectorStorage {
+  state;
+  assertSession;
+  runRootOperation;
+  constructor(state, assertSession, runRootOperation) {
+    this.state = state;
+    this.assertSession = assertSession;
+    this.runRootOperation = runRootOperation;
+  }
+  async list(input) {
+    return this.listBatch({ projectId: input.projectId, refs: [input.ref] });
+  }
+  async listBatch(input) {
+    return this.runRootOperation(() => [...new Set(input.refs.map((ref) => vectorObjectKey(input.projectId, ref)))].flatMap((key) => [...this.state.get(key)?.values() ?? []].map(({ values: _values, ...metadata }) => structuredClone(metadata))));
+  }
+  async removeBatch(input) {
+    this.assertSession(input.session, input.projectId);
+    for (const entry of input.entries) {
+      await this.remove({ session: input.session, projectId: input.projectId, ...entry });
+    }
+  }
+  async write(input) {
+    this.assertSession(input.session, input.projectId, input.value.lastCommitId);
+    const key = vectorObjectKey(input.projectId, input.value.ref);
+    const profiles = this.state.get(key) ?? new Map;
+    this.assertRevision(profiles.get(input.value.profile), input.expectedCommitId);
+    profiles.set(input.value.profile, structuredClone(input.value));
+    this.state.set(key, profiles);
+  }
+  async writeBatch(input) {
+    for (const entry of input.entries) {
+      await this.write({ session: input.session, projectId: input.projectId, ...entry });
+    }
+  }
+  async remove(input) {
+    this.assertSession(input.session, input.projectId);
+    const key = vectorObjectKey(input.projectId, input.ref);
+    const profiles = this.state.get(key);
+    this.assertRevision(profiles?.get(input.profile), input.expectedCommitId);
+    profiles?.delete(input.profile);
+    if (profiles?.size === 0)
+      this.state.delete(key);
+  }
+  assertRevision(current, expected) {
+    if ((current?.lastCommitId ?? null) !== expected) {
+      throw new MaterializationConflictError2("effective-state", "Vector changed since it was prepared.");
+    }
+  }
+}
+
+// src/storage/ontology/in-memory/materializations.ts
+class InMemoryOntologyMaterializationStorage {
+  state;
+  objects;
+  timeseries;
+  reader;
+  getTransactionToken;
+  getMaterializationLifecycle;
+  readExecution;
+  hooks;
+  sessions = new WeakMap;
+  liveSessions = new Set;
+  constructor(state, objects, timeseries, reader, getTransactionToken, getMaterializationLifecycle, readExecution, hooks = {}) {
+    this.state = state;
+    this.objects = objects;
+    this.timeseries = timeseries;
+    this.reader = reader;
+    this.getTransactionToken = getTransactionToken;
+    this.getMaterializationLifecycle = getMaterializationLifecycle;
+    this.readExecution = readExecution;
+    this.hooks = hooks;
   }
-  async* streamWork(input) {
+  async begin(input) {
+    const transactionToken = this.getTransactionToken();
+    const lifecycle = this.getMaterializationLifecycle();
+    if (!transactionToken || !lifecycle) {
+      throw new MaterializationValidationError2("Materialization sessions require an active storage transaction.");
+    }
+    assertMaterializationHeader2(input);
+    if (!await this.readExecution(input.commit.projectId, input.commit.executionId)) {
+      throw new MaterializationValidationError2(`Ontology commit execution '${input.commit.executionId}' does not exist in project '${input.commit.projectId}'.`);
+    }
+    this.assertCommitAbsent(input);
+    for (const expected of input.expected.sources)
+      this.assertSource(expected, input.commit.projectId);
+    for (const expected of input.expected.objects)
+      await this.assertObject(expected, input.commit.projectId);
+    for (const expected of input.expected.links)
+      await this.assertLink(expected, input.commit.projectId);
+    const expectedScopeRevisions = new Map;
+    for (const expected of input.expected.linkScopes) {
+      const key = linkScopeSortKey2(expected.source, expected.linkId);
+      const current = expectedScopeRevisions.get(key) ?? this.reader.effectiveLinkScope(input.commit.projectId, expected.source, expected.linkId);
+      expectedScopeRevisions.set(key, current);
+      assertExpectedLinkScopeRevision2(current.fingerprint, expected);
+    }
+    for (const expected of input.expected.points)
+      this.assertPoint(expected, input.commit.projectId);
+    const plan = input.plan ? this.requirePlan(input) : null;
+    const providerToken = {};
+    const session = {
+      providerToken,
+      header: structuredClone(input),
+      transactionToken,
+      lifecycle,
+      active: true,
+      writeOrdinal: 0,
+      work: new Map,
+      workUniqueKeys: new Set,
+      applyWork: [],
+      cardinalityWork: [],
+      eventWork: [],
+      outboxWrites: new Map,
+      workSealed: false,
+      vectorChangesStreamed: false,
+      applied: false,
+      appliedEventCount: 0,
+      incidentLinksByObject: null,
+      linkSlotStates: new Map,
+      plan
+    };
+    if (plan) {
+      for (const identity of plan.identities.values()) {
+        for (const record of structuredClone(identity.records))
+          this.addWork(session, record);
+      }
+    }
+    this.sessions.set(providerToken, session);
+    this.liveSessions.add(session);
+    lifecycle.register(providerToken);
+    return { providerToken };
+  }
+  deactivateTransaction(transactionToken) {
+    for (const session of this.liveSessions) {
+      if (session.transactionToken !== transactionToken)
+        continue;
+      this.releaseSession(session);
+    }
+  }
+  releaseSession(session) {
+    session.active = false;
+    session.work.clear();
+    session.workUniqueKeys.clear();
+    session.applyWork.length = 0;
+    session.cardinalityWork.length = 0;
+    session.eventWork.length = 0;
+    session.outboxWrites.clear();
+    session.incidentLinksByObject = null;
+    session.linkSlotStates = null;
+    this.liveSessions.delete(session);
+    session.lifecycle.complete(session.providerToken);
+  }
+  async* streamState(input) {
     const session = this.requireSession(input.session);
     assertPageRows2(input.pageRows);
-    const stream = session.workStreams[input.order];
-    if (stream.started) {
-      throw new MaterializationConflictError2("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
-    }
-    stream.started = true;
-    if (!session.workSealed) {
-      session.applyWork.sort(comparePlanWork2);
-      session.cardinalityWork.sort(compareCardinalityWork2);
-      session.eventWork.sort(compareEventWork2);
-      session.workSealed = true;
-    }
-    const records = input.order === "apply" ? session.applyWork : input.order === "cardinality" ? session.cardinalityWork : session.eventWork;
-    for (let offset = 0;offset < records.length; offset += input.pageRows) {
+    for await (const request of input.requests) {
       this.requireSession(input.session);
-      const selected = records.slice(offset, offset + input.pageRows);
-      this.hooks.observeBuffer?.(`work.${input.order}.page`, selected.length);
-      stream.emittedCount = offset + selected.length;
-      yield { records: structuredClone(selected) };
+      this.hooks.beforeRead?.("state.read");
+      const objectRefs = uniqueSorted2(request.objects, objectRefKey2, objectRefSortKey2);
+      for (let offset = 0;offset < objectRefs.length; offset += input.pageRows) {
+        this.requireSession(input.session);
+        const objects = [];
+        for (const ref of objectRefs.slice(offset, offset + input.pageRows)) {
+          objects.push(await this.reader.objectState(session.header.commit.projectId, ref));
+        }
+        this.requireSession(input.session);
+        this.hooks.observeBuffer?.("state.object.page", objects.length);
+        yield { objects, links: [], linkScopes: [], points: [] };
+      }
+      const linkRefs = uniqueSorted2(request.links, linkRefKey2, linkRefSortKey2);
+      for (let offset = 0;offset < linkRefs.length; offset += input.pageRows) {
+        this.requireSession(input.session);
+        const links = [];
+        for (const ref of linkRefs.slice(offset, offset + input.pageRows)) {
+          links.push(await this.reader.linkState(session.header.commit.projectId, ref));
+        }
+        this.requireSession(input.session);
+        this.hooks.observeBuffer?.("state.link.page", links.length);
+        yield { objects: [], links, linkScopes: [], points: [] };
+      }
+      const incidentRefs = this.incidentLinkRefs(session, request.incidentObjects);
+      for (let offset = 0;offset < incidentRefs.length; offset += input.pageRows) {
+        this.requireSession(input.session);
+        const refs = incidentRefs.slice(offset, offset + input.pageRows);
+        const links = [];
+        for (const ref of refs)
+          links.push(await this.reader.linkState(session.header.commit.projectId, ref));
+        this.requireSession(input.session);
+        this.hooks.observeBuffer?.("state.incident-link.page", links.length);
+        yield { objects: [], links, linkScopes: [], points: [] };
+      }
+      for (const scope of uniqueBy(request.linkScopes, (value) => linkScopeSortKey2(value.source, value.linkId))) {
+        this.requireSession(input.session);
+        const value = this.linkSlotState(session, scope.source, scope.linkId);
+        yield { objects: [], links: [], linkScopes: [value], points: [] };
+      }
+      const requestedPoints = uniqueSorted2(request.points, (point) => telemetryPointKey2(point.series, point.at), (point) => telemetryPointSortKey2(point.series, point.at));
+      for (let offset = 0;offset < requestedPoints.length; offset += input.pageRows) {
+        this.requireSession(input.session);
+        const points = [];
+        for (const point of requestedPoints.slice(offset, offset + input.pageRows)) {
+          const stored = getInMemoryTimeseriesMaterializerAdapter(this.timeseries).getExactPoint(session.header.commit.projectId, point.series, point.at);
+          if (stored)
+            points.push(storedPoint(stored));
+        }
+        this.requireSession(input.session);
+        this.hooks.observeBuffer?.("state.point.page", points.length);
+        if (points.length > 0)
+          yield { objects: [], links: [], linkScopes: [], points };
+      }
     }
-    this.requireSession(input.session);
-    stream.completed = true;
   }
-  async readObjectExistence(input) {
+  async stageWork(input) {
     const session = this.requireSession(input.session);
-    const result = [];
-    for (const ref of input.refs) {
-      const record = session.objectExistence.get(objectRefKey2(ref));
-      if (record) {
-        result.push({ ref: structuredClone(record.ref), exists: record.exists });
+    for (const { record, uniqueKey } of prepareMaterializationWork2(session, input)) {
+      if (session.work.has(record.recordKey) || session.workUniqueKeys.has(uniqueKey)) {
+        throw duplicateMaterializationWork2(record.recordKey);
       }
     }
-    return result;
+    const cloned = input.records.map((record) => structuredClone(record));
+    this.hooks.observeWork?.(cloned);
+    for (const record of cloned)
+      this.addWork(session, record);
+    this.hooks.observeBuffer?.("work.stage", cloned.length);
   }
-  async applyChunk(input) {
+  addWork(session, record) {
+    session.work.set(record.recordKey, record);
+    session.workUniqueKeys.add(workUniquenessKey2(record));
+    if (record.kind === "plan")
+      session.applyWork.push(record);
+    if (record.kind === "cardinality")
+      session.cardinalityWork.push(record);
+    if (record.kind === "event")
+      session.eventWork.push(record);
+  }
+  async* streamVectorChanges(input) {
     const session = this.requireSession(input.session);
+    assertPageRows2(input.pageRows);
+    this.sealWork(session, beginMaterializationVectorChanges2);
     const projectId = session.header.commit.projectId;
-    assertPlanChunkCorrelations2(input.chunk, session.header.commit);
-    assertChunkSequence(session, input.chunk);
-    this.hooks.observeBuffer?.("apply.chunk", materializationChunkRows2(input.chunk));
+    const profiled = new Set(input.objectTypeIds);
+    const changes = session.applyWork.flatMap((record) => {
+      const item = record.item;
+      if (item.kind !== "object-upsert" && item.kind !== "object-delete")
+        return [];
+      const ref = item.kind === "object-upsert" ? item.value.row.ref : item.value.ref;
+      return profiled.has(ref.objectTypeId) || (this.state.vectors.get(vectorObjectKey(projectId, ref))?.size ?? 0) > 0 ? [item] : [];
+    });
+    for (let offset = 0;offset < changes.length; offset += input.pageRows) {
+      this.requireSession(input.session);
+      yield { items: structuredClone(changes.slice(offset, offset + input.pageRows)) };
+    }
+    this.requireSession(input.session);
+  }
+  async apply(input) {
+    const session = this.requireSession(input.session);
+    this.sealWork(session, beginMaterializationApply2);
+    const cardinality = createCardinalityValidator2();
+    for (const record of session.cardinalityWork)
+      cardinality.accept(record);
+    for (let start = 0;start < session.applyWork.length; ) {
+      const phase = session.applyWork[start].applyPhase;
+      let end = start;
+      while (session.applyWork[end]?.applyPhase === phase)
+        end += 1;
+      const items = session.applyWork.slice(start, end).map((record) => record.item);
+      this.writeChunk(session, materializationPlanChunk2(items));
+      start = end;
+    }
+    const outbox = session.eventWork.map((record, ordinal) => materializationOutboxWrite2(session.header.commit, record.draft, ordinal));
+    this.writeChunk(session, materializationPlanChunk2([], outbox));
+    session.appliedEventCount = outbox.length;
+    return { eventCount: outbox.length };
+  }
+  writeChunk(session, chunk) {
+    const projectId = session.header.commit.projectId;
+    this.hooks.observeBuffer?.("apply.chunk", materializationChunkRows2(chunk));
     const write = (boundary, apply) => {
       this.hooks.beforeWrite?.(boundary, session.writeOrdinal++);
       apply();
     };
-    for (const item of input.chunk.overrides.objects.upserts)
+    for (const item of chunk.overrides.objects.upserts)
       write("override.object.upsert", () => {
         const key = projectEntityKey(projectId, objectRefKey2(item.ref));
         assertLastCommit(this.state.objectOverrides.get(key), item.expectedLastCommitId, "object override");
@@ -5065,13 +5499,13 @@ class InMemoryOntologyMaterializationStorage {
           updatedAt: item.updatedAt
         }));
       });
-    for (const item of input.chunk.overrides.objects.deletes)
+    for (const item of chunk.overrides.objects.deletes)
       write("override.object.delete", () => {
         const key = projectEntityKey(projectId, objectRefKey2(item.ref));
         assertLastCommit(this.state.objectOverrides.get(key), item.expectedLastCommitId, "object override");
         this.state.objectOverrides.delete(key);
       });
-    for (const item of input.chunk.overrides.links.edges.upserts)
+    for (const item of chunk.overrides.links.edges.upserts)
       write("override.link.upsert", () => {
         const key = projectEntityKey(projectId, linkRefKey2(item.ref));
         assertLastCommit(this.state.linkOverrides.get(key), item.expectedLastCommitId, "link edge override");
@@ -5083,13 +5517,13 @@ class InMemoryOntologyMaterializationStorage {
           updatedAt: item.updatedAt
         }));
       });
-    for (const item of input.chunk.overrides.links.edges.deletes)
+    for (const item of chunk.overrides.links.edges.deletes)
       write("override.link.delete", () => {
         const key = projectEntityKey(projectId, linkRefKey2(item.ref));
         assertLastCommit(this.state.linkOverrides.get(key), item.expectedLastCommitId, "link edge override");
         this.state.linkOverrides.delete(key);
       });
-    for (const item of input.chunk.overrides.links.slots.upserts)
+    for (const item of chunk.overrides.links.slots.upserts)
       write("override.link-slot.upsert", () => {
         const key = projectEntityKey(projectId, linkScopeKey(item.ref.source, item.ref.linkId));
         assertLastCommit(this.state.linkSlotOverrides.get(key), item.expectedLastCommitId, "link slot override");
@@ -5101,13 +5535,13 @@ class InMemoryOntologyMaterializationStorage {
           updatedAt: item.updatedAt
         }));
       });
-    for (const item of input.chunk.overrides.links.slots.deletes)
+    for (const item of chunk.overrides.links.slots.deletes)
       write("override.link-slot.delete", () => {
         const key = projectEntityKey(projectId, linkScopeKey(item.ref.source, item.ref.linkId));
         assertLastCommit(this.state.linkSlotOverrides.get(key), item.expectedLastCommitId, "link slot override");
         this.state.linkSlotOverrides.delete(key);
       });
-    for (const item of input.chunk.effective.linkDeletes)
+    for (const item of chunk.effective.linkDeletes)
       write("effective.link.delete", () => {
         this.assertLinkSync(item.expected, projectId);
         getInMemoryObjectMaterializerAdapter(this.objects).deleteExactLink({
@@ -5119,44 +5553,42 @@ class InMemoryOntologyMaterializationStorage {
           targetId: item.ref.target.primaryId
         });
       });
-    for (const item of input.chunk.effective.objectDeletes)
+    for (const item of chunk.effective.objectDeletes)
       write("effective.object.delete", () => {
         this.assertObjectSync(item.expected, projectId);
         getInMemoryObjectMaterializerAdapter(this.objects).deleteExactObject(projectId, item.ref.objectTypeId, item.ref.primaryId);
       });
-    for (const item of input.chunk.effective.objectUpserts)
+    for (const item of chunk.effective.objectUpserts)
       write("effective.object.upsert", () => {
         this.assertObjectSync(item.expected, projectId);
         getInMemoryObjectMaterializerAdapter(this.objects).applyExactObject(item.row, projectId);
       });
-    for (const item of input.chunk.effective.linkUpserts)
+    for (const item of chunk.effective.linkUpserts)
       write("effective.link.upsert", () => {
         this.assertLinkSync(item.expected, projectId);
         getInMemoryObjectMaterializerAdapter(this.objects).applyExactLink(item.row, projectId);
       });
-    for (const item of input.chunk.timeseries.pointUpserts)
+    for (const item of chunk.timeseries.pointUpserts)
       write("timeseries.point.upsert", () => {
         this.assertPoint(item.expected, projectId);
         getInMemoryTimeseriesMaterializerAdapter(this.timeseries).applyExactPoint(projectId, item.point);
       });
-    for (const item of input.chunk.outbox)
+    for (const item of chunk.outbox)
       write("outbox.insert", () => {
-        const envelope = item.envelope;
-        if (envelope.projectId !== projectId || envelope.commitId !== session.header.commit.id) {
-          throw new MaterializationValidationError2("Outbox event does not correlate with its materialization commit.");
-        }
-        assertTimestamp(item.availableAt, "Outbox availableAt");
         assertTimestamp(item.createdAt, "Outbox createdAt");
-        assertTimestamp(envelope.occurredAt, "Outbox event occurredAt");
-        const key = outboxKey(projectId, envelope.id);
+        const key = outboxKey(projectId, item.id);
         if (this.state.outbox.has(key)) {
-          throw new MaterializationConflictError2("effective-state", `Duplicate outbox event '${envelope.id}'.`);
+          throw new MaterializationConflictError2("effective-state", `Duplicate outbox event '${item.id}'.`);
         }
-        if (session.outboxEnvelopes.has(envelope.commitOrdinal))
+        if (session.outboxWrites.has(item.commitOrdinal))
           throw new MaterializationConflictError2("effective-state", "Duplicate outbox commit ordinal.");
         this.state.outbox.set(key, {
-          envelope: structuredClone(envelope),
-          availableAt: item.availableAt,
+          projectId,
+          id: item.id,
+          commitId: session.header.commit.id,
+          commitOrdinal: item.commitOrdinal,
+          event: structuredClone(item.event),
+          availableAt: item.createdAt,
           attempts: 0,
           leaseId: null,
           leaseExpiresAt: null,
@@ -5164,11 +5596,8 @@ class InMemoryOntologyMaterializationStorage {
           lastFailure: null,
           createdAt: item.createdAt
         });
-        session.outboxEnvelopes.set(envelope.commitOrdinal, structuredClone(envelope));
+        session.outboxWrites.set(item.commitOrdinal, structuredClone(item));
       });
-    for (const item of materializationPlanItems2(input.chunk)) {
-      session.appliedPlanItems.push(stableJsonStringify2(item));
-    }
   }
   async finalize(input) {
     const session = this.requireSession(input.session);
@@ -5176,6 +5605,9 @@ class InMemoryOntologyMaterializationStorage {
     this.assertCommitAbsent(session.header);
     assertFinalizationCorrelations(session, input.finalization, this.state, this.objects);
     this.hooks.beforeWrite?.("finalize", session.writeOrdinal++);
+    const touches = emptyCommitTouches(commit.projectId);
+    for (const record of session.applyWork)
+      touchPlanItem(touches, record.item);
     for (const activation of input.finalization.sourceActivations) {
       this.hooks.beforeWrite?.("source.activate", session.writeOrdinal++);
       assertTimestamp(activation.datasetVersion.createdAt, "Source dataset version createdAt");
@@ -5195,7 +5627,7 @@ class InMemoryOntologyMaterializationStorage {
           updatedAt: activation.updatedAt
         });
       }
-      activateSourceRoots(this.state, candidate, activation);
+      activateSourceRoots(this.state, candidate, activation, touches);
       this.state.sourceMaterializations.set(candidateKey, {
         ...candidate,
         status: "active",
@@ -5205,11 +5637,19 @@ class InMemoryOntologyMaterializationStorage {
         updatedAt: activation.updatedAt
       });
     }
+    if (session.plan) {
+      this.state.replacementPlans.delete(replacementPlanKey({
+        projectId: commit.projectId,
+        source: { projectionId: session.plan.sourceId },
+        materializationId: session.plan.materializationId
+      }));
+    }
     const record = {
       ...structuredClone(commit),
       result: structuredClone(input.finalization.result)
     };
     this.state.commitsById.set(commitKey(commit.projectId, commit.id), record);
+    this.state.commitTouches.set(this.state.commitsById.size, touches);
     this.state.commitIdByIdempotency.set(idempotencyKey(commit.projectId, commit.idempotencyKey), commit.id);
     const origin = ontologyCommitOriginSelector(commit.origin);
     if (origin) {
@@ -5224,6 +5664,29 @@ class InMemoryOntologyMaterializationStorage {
       throw new MaterializationValidationError2("Vector mutation does not belong to this materialization session.");
     }
   }
+  sealWork(session, begin) {
+    const sealed = session.workSealed;
+    begin(session);
+    if (sealed)
+      return;
+    session.applyWork.sort(comparePlanWork2);
+    session.cardinalityWork.sort(compareCardinalityWork2);
+    session.eventWork.sort(compareEventWork2);
+  }
+  requirePlan(header) {
+    const { commit, plan: ref } = header;
+    const plan = ref ? this.state.replacementPlans.get(replacementPlanKey({ projectId: commit.projectId, ...ref })) : undefined;
+    if (!plan || commit.intent.kind !== "projection") {
+      throw new MaterializationConflictError2("source-materialization", "A plan-bound session needs the open plan of a projection candidate.");
+    }
+    if (plan.commitId !== commit.id || plan.committedAt !== commit.committedAt) {
+      invalidCorrelation2("A plan-bound session must begin with the commit its plan carries.");
+    }
+    if (plan.watermark !== this.state.commitsById.size || [...plan.identities.values()].some((identity) => identity.plannedRevision === null)) {
+      invalidCorrelation2("A replacement plan applies only fully planned and just refreshed.");
+    }
+    return plan;
+  }
   requireSession(session) {
     const value = this.sessions.get(session.providerToken);
     if (!value || !value.active || !this.getTransactionToken() || this.getTransactionToken() !== value.transactionToken) {
@@ -5231,115 +5694,6 @@ class InMemoryOntologyMaterializationStorage {
     }
     return value;
   }
-  requireReplacement(session, input) {
-    if (session.replacement) {
-      if (session.replacement.sourceId !== input.source.projectionId || session.replacement.candidateMaterializationId !== input.candidateMaterializationId) {
-        throw new MaterializationConflictError2("source-materialization", "Materialization session already owns another replacement union.");
-      }
-      return session.replacement;
-    }
-    const projectId = session.header.commit.projectId;
-    const sourceId = input.source.projectionId;
-    const candidate = this.state.sourceMaterializations.get(sourceMaterializationKey(projectId, sourceId, input.candidateMaterializationId));
-    if (!candidate || candidate.status !== "ready") {
-      throw new MaterializationConflictError2("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
-    }
-    const previous = findActiveSourceMaterialization(this.state, projectId, sourceId);
-    if (candidate.protocol !== "replacement" || previous && (previous.protocol !== candidate.protocol || previous.projectionKind !== candidate.projectionKind)) {
-      throw new MaterializationConflictError2("source-materialization", "Source replacement kind or protocol does not match its active materialization.");
-    }
-    const replacement = {
-      sourceId,
-      candidateMaterializationId: input.candidateMaterializationId,
-      owned: new Set,
-      candidate,
-      objects: new Map,
-      links: new Map,
-      orderedObjects: [],
-      orderedLinks: null,
-      affectedScopes: new Set,
-      incidentObjects: new Map,
-      objectStreamStarted: false,
-      objectStreamCompleted: false,
-      linkStreamStarted: false,
-      linkStreamCompleted: false,
-      linksExpanded: false
-    };
-    for (const rows of [
-      previousSourceRows(this.state, candidate),
-      candidate.rowsByEntity.values()
-    ]) {
-      for (const row of rows) {
-        replacement.owned.add(projectionEntityKey2(row.assertion));
-        if (row.assertion.kind === "object") {
-          const ref = row.assertion.ref;
-          replacement.objects.set(objectRefKey2(ref), { ref, sortKey: objectRefSortKey2(ref) });
-        } else {
-          addReplacementLink(replacement, row.assertion.ref, true);
-        }
-      }
-    }
-    replacement.orderedObjects = [...replacement.objects.values()].sort((left, right) => left.sortKey.localeCompare(right.sortKey));
-    session.replacement = replacement;
-    return replacement;
-  }
-  expandReplacementLinks(session, replacement) {
-    if (replacement.linksExpanded)
-      return;
-    const projectId = session.header.commit.projectId;
-    const incident = replacement.incidentObjects;
-    const touchesIncident = (ref) => incident.has(objectRefKey2(ref.source)) || incident.has(objectRefKey2(ref.target));
-    const adapter = getInMemoryObjectMaterializerAdapter(this.objects);
-    if (incident.size > 0) {
-      adapter.visitExactLinks(projectId, (row) => {
-        const ref = linkRef(row);
-        if (touchesIncident(ref))
-          addReplacementLink(replacement, ref, true);
-      });
-      for (const override of this.state.linkOverrides.values()) {
-        if (override.projectId !== projectId)
-          continue;
-        if (touchesIncident(override.ref))
-          addReplacementLink(replacement, override.ref, true);
-      }
-      for (const override of this.state.linkSlotOverrides.values()) {
-        if (override.projectId !== projectId)
-          continue;
-        const ref = {
-          source: override.ref.source,
-          linkId: override.ref.linkId,
-          target: override.value.target
-        };
-        if (touchesIncident(ref))
-          addReplacementLink(replacement, ref, true);
-      }
-      for (const [scopeKey, rows] of this.state.activeSourceLinkScopes) {
-        if (JSON.parse(scopeKey)[0] !== projectId)
-          continue;
-        for (const row of rows.values()) {
-          if (row.assertion.kind === "link" && touchesIncident(row.assertion.ref)) {
-            addReplacementLink(replacement, row.assertion.ref, true);
-          }
-        }
-      }
-    }
-    const scopes = new Map;
-    for (const { ref } of replacement.links.values()) {
-      const key = linkScopeSortKey2(ref.source, ref.linkId);
-      if (replacement.affectedScopes.has(key))
-        scopes.set(key, ref);
-    }
-    for (const scope of scopes.values()) {
-      adapter.visitExactScopeLinks(projectId, scope.source.objectTypeId, scope.source.primaryId, scope.linkId, (row) => {
-        addReplacementLink(replacement, linkRef(row), false);
-      });
-      const override = this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(scope.source, scope.linkId)));
-      if (override)
-        addReplacementLink(replacement, { ...scope, target: override.value.target }, false);
-    }
-    replacement.linksExpanded = true;
-    replacement.orderedLinks = null;
-  }
   assertCommitAbsent(header) {
     if (this.state.commitsById.has(commitKey(header.commit.projectId, header.commit.id))) {
       throw new MaterializationConflictError2("idempotency", `Ontology commit '${header.commit.id}' already exists.`);
@@ -5384,98 +5738,20 @@ class InMemoryOntologyMaterializationStorage {
       throw new MaterializationConflictError2("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
     }
   }
-  async objectState(session, ref) {
-    const projectId = session.header.commit.projectId;
-    const row = await this.objects.getByPrimaryId({
-      projectId,
-      objectTypeId: ref.objectTypeId,
-      primaryId: ref.primaryId
-    });
-    return {
-      ref: structuredClone(ref),
-      source: this.findActiveObjectSource(projectId, ref),
-      override: structuredClone(publicObjectOverride(this.state.objectOverrides.get(projectEntityKey(projectId, objectRefKey2(ref))))),
-      effective: row ? objectSnapshot(row) : null,
-      latestTelemetry: getInMemoryTimeseriesMaterializerAdapter(this.timeseries).listLatestForObject(projectId, ref.objectTypeId, ref.primaryId).map(storedPoint)
-    };
-  }
-  async linkState(session, ref) {
-    const projectId = session.header.commit.projectId;
-    const row = getInMemoryObjectMaterializerAdapter(this.objects).getExactLinkRow(projectId, {
-      sourceTypeId: ref.source.objectTypeId,
-      sourceId: ref.source.primaryId,
-      linkId: ref.linkId,
-      targetTypeId: ref.target.objectTypeId,
-      targetId: ref.target.primaryId
-    });
-    return {
-      ref: structuredClone(ref),
-      source: this.findActiveLinkSource(projectId, ref),
-      override: structuredClone(publicLinkOverride(this.state.linkOverrides.get(projectEntityKey(projectId, linkRefKey2(ref))))),
-      slotOverride: structuredClone(publicLinkSlotOverride(this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(ref.source, ref.linkId))))),
-      effective: row ? linkSnapshot(row) : null
-    };
-  }
   linkSlotState(session, source, linkId) {
     session.linkSlotStates ??= new Map;
     const key = linkScopeSortKey2(source, linkId);
     const existing = session.linkSlotStates.get(key);
     if (existing)
       return structuredClone(existing);
-    const computed = this.computeLinkSlotState(session.header.commit.projectId, source, linkId);
-    session.linkSlotStates.set(key, computed);
-    return structuredClone(computed);
-  }
-  computeLinkSlotState(projectId, source, linkId) {
-    const value = this.computeEffectiveLinkScope(projectId, source, linkId);
-    return {
-      ...value,
-      sourceAssertion: this.findActiveLinkScopeSource(projectId, source, linkId),
-      override: structuredClone(publicLinkSlotOverride(this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(source, linkId)))))
-    };
-  }
-  computeEffectiveLinkScope(projectId, source, linkId) {
-    const rows = [];
-    getInMemoryObjectMaterializerAdapter(this.objects).visitExactScopeLinks(projectId, source.objectTypeId, source.primaryId, linkId, (row) => rows.push(row));
-    rows.sort((left, right) => linkRefSortKey2(linkRef(left)).localeCompare(linkRefSortKey2(linkRef(right))));
-    const accumulator = startScopeAccumulator2(source, linkId);
-    for (let offset = 0;offset < rows.length; offset += 1000) {
-      const page = rows.slice(offset, offset + 1000);
-      this.hooks.observeBuffer?.("state.link-scope.page", page.length);
-      for (const row of page) {
-        appendScopeSnapshot2(accumulator, linkSnapshot(row));
-      }
-    }
-    const effective = rows.length === 1 ? linkSnapshot(rows[0]) : null;
-    return {
-      ...finishScopeAccumulator2(accumulator),
-      effective
-    };
-  }
-  findActiveLinkScopeSource(projectId, source, linkId) {
-    const rows = this.state.activeSourceLinkScopes.get(projectEntityKey(projectId, linkScopeSortKey2(source, linkId)));
-    if (rows && rows.size > 1)
-      throw new MaterializationConflictError2("source-materialization", `Multiple active source links assert cardinality-one scope '${source.objectTypeId}.${linkId}'.`);
-    return structuredClone(rows?.values().next().value ?? null);
-  }
-  findActiveObjectSource(projectId, ref) {
-    const found = this.findActiveSource(projectId, projectionEntityKey2({ kind: "object", ref }));
-    return found?.assertion.kind === "object" ? found : null;
-  }
-  findActiveLinkSource(projectId, ref) {
-    const found = this.findActiveSource(projectId, projectionEntityKey2({ kind: "link", ref }));
-    return found?.assertion.kind === "link" ? found : null;
-  }
-  findActiveSource(projectId, entityKey) {
-    const rows = this.state.activeSourceRows.get(projectEntityKey(projectId, entityKey));
-    if (rows && rows.size > 1)
-      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert ${entityKey}.`);
-    return structuredClone(rows?.values().next().value ?? null);
+    const computed = this.reader.linkSlotState(session.header.commit.projectId, source, linkId);
+    session.linkSlotStates.set(key, computed);
+    return structuredClone(computed);
   }
   incidentLinkRefs(session, objects) {
     if (objects.length === 0)
       return [];
-    session.incidentLinksByObject ??= this.buildIncidentLinkIndex(session.header.commit.projectId);
+    session.incidentLinksByObject ??= this.reader.incidentLinkIndex(session.header.commit.projectId);
     const selected = new Map;
     for (const object of objects) {
       for (const ref of session.incidentLinksByObject.get(objectRefKey2(object)) ?? []) {
@@ -5484,59 +5760,22 @@ class InMemoryOntologyMaterializationStorage {
     }
     return [...selected.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, ref]) => ref);
   }
-  buildIncidentLinkIndex(projectId) {
-    const mutable = new Map;
-    const consider = (ref) => {
-      const sortKey = linkRefSortKey2(ref);
-      for (const endpoint of [ref.source, ref.target]) {
-        const key = objectRefKey2(endpoint);
-        const links = mutable.get(key) ?? new Map;
-        links.set(sortKey, structuredClone(ref));
-        mutable.set(key, links);
-      }
-    };
-    getInMemoryObjectMaterializerAdapter(this.objects).visitExactLinks(projectId, (row) => consider(linkRef(row)));
-    for (const override of this.state.linkOverrides.values()) {
-      if (override.projectId === projectId)
-        consider(override.ref);
-    }
-    for (const override of this.state.linkSlotOverrides.values()) {
-      if (override.projectId !== projectId)
-        continue;
-      consider({
-        source: override.ref.source,
-        linkId: override.ref.linkId,
-        target: override.value.target
-      });
-    }
-    for (const [scopeKey, rows] of this.state.activeSourceLinkScopes) {
-      if (JSON.parse(scopeKey)[0] !== projectId)
-        continue;
-      for (const row of rows.values()) {
-        if (row.assertion.kind === "link")
-          consider(row.assertion.ref);
-      }
-    }
-    const index = new Map;
-    for (const [objectKey, refs] of mutable) {
-      index.set(objectKey, [...refs.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, ref]) => ref));
-    }
-    return index;
-  }
 }
 
 // src/storage/ontology/in-memory/outbox.ts
 class InMemoryOntologyOutboxStorage {
   state;
   runRootOperation;
-  constructor(state, runRootOperation) {
+  readExecution;
+  constructor(state, runRootOperation, readExecution) {
     this.state = state;
     this.runRootOperation = runRootOperation;
+    this.readExecution = readExecution;
   }
   async claim(input) {
     return this.runRootOperation(() => this.claimUnlocked(input));
   }
-  claimUnlocked(input) {
+  async claimUnlocked(input) {
     assertNonblank(input.projectId, "Ontology outbox project id");
     assertPositiveLimit(input.limit);
     const now = assertTimestamp(input.now, "Ontology outbox claim time");
@@ -5547,7 +5786,7 @@ class InMemoryOntologyOutboxStorage {
     }
     const rows = [];
     for (const row of this.state.outbox.values()) {
-      if (row.envelope.projectId !== input.projectId)
+      if (row.projectId !== input.projectId)
         continue;
       assertPairedLease(row);
       if (row.publishedAt !== null || Date.parse(row.availableAt) > now)
@@ -5556,16 +5795,23 @@ class InMemoryOntologyOutboxStorage {
         continue;
       insertBounded(rows, row, input.limit, compareClaimRows);
     }
-    return rows.map((row) => {
-      const claimed = {
-        ...row,
-        attempts: row.attempts + 1,
-        leaseId: input.leaseId,
-        leaseExpiresAt: input.leaseExpiresAt
-      };
-      this.state.outbox.set(outboxKey(input.projectId, row.envelope.id), structuredClone(claimed));
-      return structuredClone(claimed);
-    });
+    const claimed = rows.map((row) => ({
+      ...row,
+      attempts: row.attempts + 1,
+      leaseId: input.leaseId,
+      leaseExpiresAt: input.leaseExpiresAt
+    }));
+    const contexts = new Map;
+    for (const commitId of new Set(claimed.map((row) => row.commitId))) {
+      const commit = this.state.commitsById.get(commitKey(input.projectId, commitId));
+      const execution = commit && await this.readExecution(input.projectId, commit.executionId);
+      if (commit && execution)
+        contexts.set(commitId, { commit, execution });
+    }
+    const records = claimedOutboxRows2(structuredClone(claimed), (commitId) => contexts.get(commitId));
+    for (const row of claimed)
+      this.state.outbox.set(outboxKey(input.projectId, row.id), row);
+    return records;
   }
   async markPublished(input) {
     await this.runRootOperation(() => this.markPublishedUnlocked(input));
@@ -5613,7 +5859,7 @@ class InMemoryOntologyOutboxStorage {
       let retryingCount = 0;
       let maxAttempts = 0;
       for (const row of this.state.outbox.values()) {
-        if (row.envelope.projectId !== input.projectId || row.publishedAt !== null)
+        if (row.projectId !== input.projectId || row.publishedAt !== null)
           continue;
         pendingCount += 1;
         if (row.attempts > 0)
@@ -5633,7 +5879,7 @@ class InMemoryOntologyOutboxStorage {
     const rows = [];
     for (const entry of this.state.outbox.entries()) {
       const [, row] = entry;
-      if (row.envelope.projectId !== input.projectId || row.publishedAt === null || Date.parse(row.publishedAt) >= cutoff) {
+      if (row.projectId !== input.projectId || row.publishedAt === null || Date.parse(row.publishedAt) >= cutoff) {
         continue;
       }
       insertBounded(rows, entry, input.limit, ([, left], [, right]) => comparePublishedRows(left, right));
@@ -5663,10 +5909,10 @@ class InMemoryOntologyOutboxStorage {
   }
 }
 function compareClaimRows(left, right) {
-  return left.createdAt.localeCompare(right.createdAt) || left.envelope.commitId.localeCompare(right.envelope.commitId) || left.envelope.commitOrdinal - right.envelope.commitOrdinal;
+  return left.createdAt.localeCompare(right.createdAt) || left.commitId.localeCompare(right.commitId) || left.commitOrdinal - right.commitOrdinal;
 }
 function comparePublishedRows(left, right) {
-  return (left.publishedAt ?? "").localeCompare(right.publishedAt ?? "") || left.envelope.id.localeCompare(right.envelope.id);
+  return (left.publishedAt ?? "").localeCompare(right.publishedAt ?? "") || left.id.localeCompare(right.id);
 }
 function assertPositiveLimit(limit) {
   if (!Number.isSafeInteger(limit) || limit <= 0) {
@@ -5887,23 +6133,6 @@ class InMemoryOntologySourceStorage {
     }
     return { rowsDeleted, materializationsDeleted };
   }
-  async summarizeTerminal(input) {
-    return this.runRootOperation(() => {
-      assertNonblank(input.projectId, "Terminal source summary project id");
-      let count = 0;
-      let oldestTerminalAt = null;
-      for (const materialization of this.state.sourceMaterializations.values()) {
-        if (materialization.projectId !== input.projectId || materialization.status !== "superseded" && materialization.status !== "abandoned" || materialization.terminalAt === null) {
-          continue;
-        }
-        count += 1;
-        if (oldestTerminalAt === null || materialization.terminalAt < oldestTerminalAt) {
-          oldestTerminalAt = materialization.terminalAt;
-        }
-      }
-      return { count, oldestTerminalAt };
-    });
-  }
   async assertCurrentExecution(input) {
     await this.assertExecution({
       projectId: input.projectId,
@@ -5954,7 +6183,9 @@ class InMemoryOntologySourceStorage {
       terminalAt: abandonedAt,
       updatedAt: abandonedAt
     };
-    this.state.sourceMaterializations.set(sourceMaterializationKey(materialization.projectId, materialization.source.projectionId, materialization.materializationId), abandoned);
+    const key = sourceMaterializationKey(materialization.projectId, materialization.source.projectionId, materialization.materializationId);
+    this.state.sourceMaterializations.set(key, abandoned);
+    this.state.replacementPlans.delete(key);
     return sourceMaterializationRecord(abandoned);
   }
   findRunCandidates(projectId, sourceId, projectionRunId) {
@@ -6101,6 +6332,138 @@ function compareTerminalMaterializations([, left], [, right]) {
   return (left.terminalAt ?? "").localeCompare(right.terminalAt ?? "") || left.source.projectionId.localeCompare(right.source.projectionId) || left.materializationId.localeCompare(right.materializationId);
 }
 
+// src/storage/ontology/in-memory/state-reader.ts
+class InMemoryMaterializationStateReader {
+  state;
+  objects;
+  timeseries;
+  hooks;
+  constructor(state, objects, timeseries, hooks = {}) {
+    this.state = state;
+    this.objects = objects;
+    this.timeseries = timeseries;
+    this.hooks = hooks;
+  }
+  async objectState(projectId, ref) {
+    const row = await this.objects.getByPrimaryId({
+      projectId,
+      objectTypeId: ref.objectTypeId,
+      primaryId: ref.primaryId
+    });
+    return {
+      ref: structuredClone(ref),
+      source: this.findActiveObjectSource(projectId, ref),
+      override: structuredClone(publicObjectOverride(this.state.objectOverrides.get(projectEntityKey(projectId, objectRefKey2(ref))))),
+      effective: row ? objectSnapshot(row) : null,
+      latestTelemetry: getInMemoryTimeseriesMaterializerAdapter(this.timeseries).listLatestForObject(projectId, ref.objectTypeId, ref.primaryId).map(storedPoint)
+    };
+  }
+  latestTelemetry(projectId, ref) {
+    return getInMemoryTimeseriesMaterializerAdapter(this.timeseries).listLatestForObject(projectId, ref.objectTypeId, ref.primaryId).map(storedPoint);
+  }
+  async linkState(projectId, ref) {
+    const row = getInMemoryObjectMaterializerAdapter(this.objects).getExactLinkRow(projectId, {
+      sourceTypeId: ref.source.objectTypeId,
+      sourceId: ref.source.primaryId,
+      linkId: ref.linkId,
+      targetTypeId: ref.target.objectTypeId,
+      targetId: ref.target.primaryId
+    });
+    return {
+      ref: structuredClone(ref),
+      source: this.findActiveLinkSource(projectId, ref),
+      override: structuredClone(publicLinkOverride(this.state.linkOverrides.get(projectEntityKey(projectId, linkRefKey2(ref))))),
+      slotOverride: structuredClone(publicLinkSlotOverride(this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(ref.source, ref.linkId))))),
+      effective: row ? linkSnapshot(row) : null
+    };
+  }
+  linkSlotState(projectId, source, linkId) {
+    const value = this.effectiveLinkScope(projectId, source, linkId);
+    return {
+      ...value,
+      sourceAssertion: this.findActiveLinkScopeSource(projectId, source, linkId),
+      override: structuredClone(publicLinkSlotOverride(this.state.linkSlotOverrides.get(projectEntityKey(projectId, linkScopeKey(source, linkId)))))
+    };
+  }
+  effectiveLinkScope(projectId, source, linkId) {
+    const rows = [];
+    getInMemoryObjectMaterializerAdapter(this.objects).visitExactScopeLinks(projectId, source.objectTypeId, source.primaryId, linkId, (row) => rows.push(row));
+    rows.sort((left, right) => linkRefSortKey2(linkRef(left)).localeCompare(linkRefSortKey2(linkRef(right))));
+    const accumulator = startScopeAccumulator2(source, linkId);
+    for (let offset = 0;offset < rows.length; offset += 1000) {
+      const page = rows.slice(offset, offset + 1000);
+      this.hooks.observeBuffer?.("state.link-scope.page", page.length);
+      for (const row of page) {
+        appendScopeSnapshot2(accumulator, linkSnapshot(row));
+      }
+    }
+    const effective = rows.length === 1 ? linkSnapshot(rows[0]) : null;
+    return {
+      ...finishScopeAccumulator2(accumulator),
+      effective
+    };
+  }
+  findActiveLinkScopeSource(projectId, source, linkId) {
+    const rows = this.state.activeSourceLinkScopes.get(projectEntityKey(projectId, linkScopeSortKey2(source, linkId)));
+    if (rows && rows.size > 1)
+      throw new MaterializationConflictError2("source-materialization", `Multiple active source links assert cardinality-one scope '${source.objectTypeId}.${linkId}'.`);
+    return structuredClone(rows?.values().next().value ?? null);
+  }
+  findActiveObjectSource(projectId, ref) {
+    const found = this.findActiveSource(projectId, projectionEntityKey2({ kind: "object", ref }));
+    return found?.assertion.kind === "object" ? found : null;
+  }
+  findActiveLinkSource(projectId, ref) {
+    const found = this.findActiveSource(projectId, projectionEntityKey2({ kind: "link", ref }));
+    return found?.assertion.kind === "link" ? found : null;
+  }
+  findActiveSource(projectId, entityKey) {
+    const rows = this.state.activeSourceRows.get(projectEntityKey(projectId, entityKey));
+    if (rows && rows.size > 1)
+      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert ${entityKey}.`);
+    return structuredClone(rows?.values().next().value ?? null);
+  }
+  incidentLinkIndex(projectId) {
+    const mutable = new Map;
+    const consider = (ref) => {
+      const sortKey = linkRefSortKey2(ref);
+      for (const endpoint of [ref.source, ref.target]) {
+        const key = objectRefKey2(endpoint);
+        const links = mutable.get(key) ?? new Map;
+        links.set(sortKey, structuredClone(ref));
+        mutable.set(key, links);
+      }
+    };
+    getInMemoryObjectMaterializerAdapter(this.objects).visitExactLinks(projectId, (row) => consider(linkRef(row)));
+    for (const override of this.state.linkOverrides.values()) {
+      if (override.projectId === projectId)
+        consider(override.ref);
+    }
+    for (const override of this.state.linkSlotOverrides.values()) {
+      if (override.projectId !== projectId)
+        continue;
+      consider({
+        source: override.ref.source,
+        linkId: override.ref.linkId,
+        target: override.value.target
+      });
+    }
+    for (const [scopeKey, rows] of this.state.activeSourceLinkScopes) {
+      if (JSON.parse(scopeKey)[0] !== projectId)
+        continue;
+      for (const row of rows.values()) {
+        if (row.assertion.kind === "link")
+          consider(row.assertion.ref);
+      }
+    }
+    const index = new Map;
+    for (const [objectKey, refs] of mutable) {
+      index.set(objectKey, [...refs.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, ref]) => ref));
+    }
+    return index;
+  }
+}
+
 // src/storage/ontology/in-memory/testing.ts
 var testingAdapters = new WeakMap;
 function registerInMemoryOntologyStorageTestingAdapter(storage, adapter) {
@@ -6229,61 +6592,6 @@ class InMemoryVectorIndexingStorage {
   }
 }
 
-// src/storage/ontology/in-memory/vectors.ts
-function vectorObjectKey(projectId, ref) {
-  return JSON.stringify([projectId, ref.objectTypeId, ref.primaryId]);
-}
-
-class InMemoryOntologyVectorStorage {
-  state;
-  assertSession;
-  runRootOperation;
-  constructor(state, assertSession, runRootOperation) {
-    this.state = state;
-    this.assertSession = assertSession;
-    this.runRootOperation = runRootOperation;
-  }
-  async list(input) {
-    return this.listBatch({ projectId: input.projectId, refs: [input.ref] });
-  }
-  async listBatch(input) {
-    return this.runRootOperation(() => [...new Set(input.refs.map((ref) => vectorObjectKey(input.projectId, ref)))].flatMap((key) => [...this.state.get(key)?.values() ?? []].map(({ values: _values, ...metadata }) => structuredClone(metadata))));
-  }
-  async removeBatch(input) {
-    this.assertSession(input.session, input.projectId);
-    for (const entry of input.entries) {
-      await this.remove({ session: input.session, projectId: input.projectId, ...entry });
-    }
-  }
-  async write(input) {
-    this.assertSession(input.session, input.projectId, input.value.lastCommitId);
-    const key = vectorObjectKey(input.projectId, input.value.ref);
-    const profiles = this.state.get(key) ?? new Map;
-    this.assertRevision(profiles.get(input.value.profile), input.expectedCommitId);
-    profiles.set(input.value.profile, structuredClone(input.value));
-    this.state.set(key, profiles);
-  }
-  async writeBatch(input) {
-    for (const entry of input.entries) {
-      await this.write({ session: input.session, projectId: input.projectId, ...entry });
-    }
-  }
-  async remove(input) {
-    this.assertSession(input.session, input.projectId);
-    const key = vectorObjectKey(input.projectId, input.ref);
-    const profiles = this.state.get(key);
-    this.assertRevision(profiles?.get(input.profile), input.expectedCommitId);
-    profiles?.delete(input.profile);
-    if (profiles?.size === 0)
-      this.state.delete(key);
-  }
-  assertRevision(current, expected) {
-    if ((current?.lastCommitId ?? null) !== expected) {
-      throw new MaterializationConflictError2("effective-state", "Vector changed since it was prepared.");
-    }
-  }
-}
-
 // src/storage/ontology/in-memory/index.ts
 class InMemoryOntologyStorage {
   state = createInMemoryOntologyState();
@@ -6292,6 +6600,7 @@ class InMemoryOntologyStorage {
   commits;
   sources;
   materializations;
+  replacementPlans;
   outbox;
   testHooks = {};
   testingAdapter = {
@@ -6304,13 +6613,16 @@ class InMemoryOntologyStorage {
     getInMemoryObjectMaterializerAdapter(objects).setVectorReader((projectId, ref, profile) => this.state.vectors.get(vectorObjectKey(projectId, ref))?.get(profile));
     this.commits = new InMemoryOntologyCommitStorage(this.state, options.runRootOperation);
     this.sources = new InMemoryOntologySourceStorage(this.state, options.runRootOperation, options.assertSourceMaterializationExecution);
-    this.outbox = new InMemoryOntologyOutboxStorage(this.state, options.runRootOperation);
-    this.materializations = new InMemoryOntologyMaterializationStorage(this.state, objects, timeseries, options.getTransactionToken, options.getMaterializationLifecycle, options.executionExists, {
+    this.outbox = new InMemoryOntologyOutboxStorage(this.state, options.runRootOperation, options.readExecution);
+    const hooks = {
       beforeRead: (boundary) => this.testHooks.beforeRead?.(boundary),
       beforeWrite: (boundary, ordinal) => this.testHooks.beforeWrite?.(boundary, ordinal),
       observeBuffer: (boundary, rows) => this.testHooks.observeBuffer?.(boundary, rows),
       observeWork: (records) => this.testHooks.observeWork?.(records)
-    });
+    };
+    const reader = new InMemoryMaterializationStateReader(this.state, objects, timeseries, hooks);
+    this.materializations = new InMemoryOntologyMaterializationStorage(this.state, objects, timeseries, reader, options.getTransactionToken, options.getMaterializationLifecycle, options.readExecution, hooks);
+    this.replacementPlans = new InMemoryOntologyReplacementPlanStorage(this.state, objects, reader, options.runRootOperation, options.assertSourceMaterializationExecution, hooks);
     registerInMemoryOntologyStorageTestingAdapter(this, this.testingAdapter);
   }
   setTestHooks(hooks) {
@@ -6827,14 +7139,16 @@ class InMemoryProjectionRunStorage2 {
       assertProjectionRunNonEmpty2(input.projectId, "projectId");
       assertProjectionRunListWindow2(input.limit, "limit");
       assertProjectionRunListWindow2(input.offset, "offset");
-      if (input.statuses?.length === 0)
+      if (input.statuses?.length === 0 || input.errorCodes?.length === 0) {
         return { runs: [], hasMore: false, total: 0 };
+      }
       const order = input.order ?? "desc";
       const offset = input.offset ?? 0;
       const limit = input.limit ?? this.rows.size;
       const statuses = input.statuses ? new Set(input.statuses) : null;
       const objectTypeIds = input.objectTypeIds ? new Set(input.objectTypeIds) : null;
-      const filtered = [...this.rows.values()].filter((record) => record.projectId === input.projectId).filter((record) => input.projectionId ? record.identity.projectionId === input.projectionId : true).filter((record) => input.projectionKind ? record.identity.projectionKind === input.projectionKind : true).filter((record) => input.datasetId ? record.identity.datasetVersion.datasetId === input.datasetId : true).filter((record) => input.datasetVersionId ? record.identity.datasetVersion.versionId === input.datasetVersionId : true).filter((record) => objectTypeIds ? projectionRunObjectTypesVisible2(record, (id) => objectTypeIds.has(id)) : true).filter((record) => statuses ? statuses.has(record.status) : true).filter((record) => matchesRunListDateFilters(record, {
+      const errorCodes = input.errorCodes ? new Set(input.errorCodes) : null;
+      const filtered = [...this.rows.values()].filter((record) => record.projectId === input.projectId).filter((record) => input.projectionId ? record.identity.projectionId === input.projectionId : true).filter((record) => input.projectionKind ? record.identity.projectionKind === input.projectionKind : true).filter((record) => input.datasetId ? record.identity.datasetVersion.datasetId === input.datasetId : true).filter((record) => input.datasetVersionId ? record.identity.datasetVersion.versionId === input.datasetVersionId : true).filter((record) => objectTypeIds ? projectionRunObjectTypesVisible2(record, (id) => objectTypeIds.has(id)) : true).filter((record) => statuses ? statuses.has(record.status) : true).filter((record) => errorCodes ? record.error !== undefined && errorCodes.has(record.error.code) : true).filter((record) => matchesRunListDateFilters(record, {
         statuses,
         startedAfter: input.startedAfter,
         startedBefore: input.startedBefore
@@ -7018,7 +7332,7 @@ class InMemoryShareGrantStorage2 {
   rows = new Map;
   async create(input) {
     const record = normalizeShareGrantCreate2(input);
-    const key = rowKey(record.projectId, record.id);
+    const key = rowKey2(record.projectId, record.id);
     const duplicateTokenHash = [...this.rows.values()].some((current) => current.projectId === record.projectId && current.tokenHash === record.tokenHash);
     if (this.rows.has(key) || duplicateTokenHash) {
       throw new ShareGrantStorageError2("duplicate", `[Sixb] Share grant '${record.id}' conflicts with an existing record.`);
@@ -7028,7 +7342,7 @@ class InMemoryShareGrantStorage2 {
   }
   async getById(input) {
     const normalized = normalizeGetShareGrantByIdInput2(input);
-    const record = this.rows.get(rowKey(normalized.projectId, normalized.id));
+    const record = this.rows.get(rowKey2(normalized.projectId, normalized.id));
     return record ? cloneShareGrantRecord2(record) : null;
   }
   async list(input) {
@@ -7044,7 +7358,7 @@ class InMemoryShareGrantStorage2 {
   }
   async revoke(input) {
     const normalized = normalizeRevokeShareGrantInput2(input);
-    const key = rowKey(normalized.projectId, normalized.id);
+    const key = rowKey2(normalized.projectId, normalized.id);
     const current = this.rows.get(key);
     if (!current)
       return null;
@@ -7072,7 +7386,7 @@ function compareShareGrants(left, right) {
     return created;
   return left.id === right.id ? 0 : left.id < right.id ? 1 : -1;
 }
-function rowKey(projectId, id) {
+function rowKey2(projectId, id) {
   return `${projectId}\x00${id}`;
 }
 // src/storage/share-sessions/in-memory.ts
@@ -7088,7 +7402,7 @@ class InMemoryShareSessionStorage2 {
     if (!grant) {
       throw new ShareSessionStorageError2("invalid_input", `[Sixb] Share grant '${record.grantId}' does not exist in project '${record.projectId}'.`);
     }
-    const key = rowKey2(record.projectId, record.id);
+    const key = rowKey3(record.projectId, record.id);
     const duplicateTokenHash = [...this.rows.values()].some((current) => current.projectId === record.projectId && current.tokenHash === record.tokenHash);
     if (this.rows.has(key) || duplicateTokenHash) {
       throw new ShareSessionStorageError2("duplicate", `[Sixb] Share session '${record.id}' conflicts with an existing record.`);
@@ -7098,12 +7412,12 @@ class InMemoryShareSessionStorage2 {
   }
   async getById(input) {
     const normalized = normalizeGetShareSessionByIdInput2(input);
-    const record = this.rows.get(rowKey2(normalized.projectId, normalized.id));
+    const record = this.rows.get(rowKey3(normalized.projectId, normalized.id));
     return record ? cloneShareSessionRecord2(record) : null;
   }
   async renewIfValid(input) {
     const normalized = normalizeRenewShareSessionIfValidInput2(input);
-    const key = rowKey2(normalized.projectId, normalized.id);
+    const key = rowKey3(normalized.projectId, normalized.id);
     const current = this.rows.get(key);
     if (!current || current.grantId !== normalized.grantId || current.tokenHash !== normalized.tokenHash || current.revokedAt !== undefined || current.createdAt.getTime() > normalized.now.getTime() || current.expiresAt.getTime() <= normalized.now.getTime() || current.absoluteExpiresAt.getTime() <= normalized.now.getTime()) {
       return null;
@@ -7115,7 +7429,7 @@ class InMemoryShareSessionStorage2 {
   }
   async revoke(input) {
     const normalized = normalizeRevokeShareSessionInput2(input);
-    const key = rowKey2(normalized.projectId, normalized.id);
+    const key = rowKey3(normalized.projectId, normalized.id);
     const current = this.rows.get(key);
     if (!current)
       return null;
@@ -7133,7 +7447,7 @@ class InMemoryShareSessionStorage2 {
     this.rows = new Map([...snapshot].map(([key, record]) => [key, parseShareSessionRecord2(record)]));
   }
 }
-function rowKey2(projectId, id) {
+function rowKey3(projectId, id) {
   return `${projectId}\x00${id}`;
 }
 // src/storage/sync-runs/types.ts
@@ -8160,6 +8474,7 @@ class InMemoryStorage2 {
   webhookRunStorage = new InMemoryWebhookRunStorage2(this.executionStorage);
   rulesStorage = new InMemoryRulesStorage2;
   fileUploadSessionStorage = new InMemoryFileUploadSessions2;
+  fileDownloadGrantStorage = new InMemoryFileDownloadGrantStorage;
   connectorConnectionStorage;
   auth;
   executions;
@@ -8178,6 +8493,7 @@ class InMemoryStorage2 {
   shareGrants;
   shareSessions;
   fileUploadSessions;
+  fileDownloadGrants;
   connectorConnections;
   constructor(options = {}) {
     this.connectorConnectionStorage = new InMemoryConnectorConnectionStorage2(options.connectorConnections);
@@ -8201,13 +8517,14 @@ class InMemoryStorage2 {
     this.shareGrants = createOperationScopedFacade2(this.shareGrantStorage, scope);
     this.shareSessions = createOperationScopedFacade2(this.shareSessionStorage, scope);
     this.fileUploadSessions = createOperationScopedFacade2(this.fileUploadSessionStorage, scope);
+    this.fileDownloadGrants = createOperationScopedFacade2(this.fileDownloadGrantStorage, scope);
     this.connectorConnections = createOperationScopedFacade2(this.connectorConnectionStorage, scope);
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
       runRootOperation: async (run) => run(),
       getTransactionToken: () => this.getActiveTransactionToken(),
       getMaterializationLifecycle: () => this.getActiveMaterializationLifecycle(),
       assertSourceMaterializationExecution: (input) => this.projectionRunStorage.assertSourceMaterializationExecutionUnlocked(input),
-      executionExists: async (projectId, executionId) => await this.executionStorage.getById({ projectId, id: executionId }) !== null
+      readExecution: (projectId, executionId) => this.executionStorage.getById({ projectId, id: executionId })
     });
     this.ontology = createOntologyOperationScope2(this.ontologyStorage, scope);
     this.ontologyStorage.registerTestingAlias(this.ontology);
@@ -8361,6 +8678,7 @@ class InMemoryStorage2 {
       shareGrants: this.shareGrantStorage,
       shareSessions: this.shareSessionStorage,
       fileUploadSessions: this.fileUploadSessionStorage,
+      fileDownloadGrants: this.fileDownloadGrantStorage,
       connectorConnections: this.connectorConnectionStorage,
       ping: async () => {
         return;
@@ -8392,6 +8710,7 @@ class InMemoryStorage2 {
       shareGrants: this.shareGrantStorage.snapshot(),
       shareSessions: this.shareSessionStorage.snapshot(),
       fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
+      fileDownloadGrants: this.fileDownloadGrantStorage.snapshot(),
       connectorConnections: this.connectorConnectionStorage.snapshot()
     };
   }
@@ -8416,25 +8735,65 @@ class InMemoryStorage2 {
     this.shareGrantStorage.restore(snapshot.shareGrants);
     this.shareSessionStorage.restore(snapshot.shareSessions);
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions);
+    this.fileDownloadGrantStorage.restore(snapshot.fileDownloadGrants);
     this.connectorConnectionStorage.restore(snapshot.connectorConnections);
   }
 }
+// src/storage/objects/query-preparation.ts
+function isQueryPreparationCapableStorage(storage) {
+  return "prepareObjectQueries" in storage && typeof storage.prepareObjectQueries === "function";
+}
+async function prepareObjectQueries2(input) {
+  if (!isQueryPreparationCapableStorage(input.storage)) {
+    throw new Error("[Sixb] This storage provider does not support object query preparation");
+  }
+  const values = input.ontology.getValueTypesById();
+  const objectTypes = input.ontology.listObjectTypes().map((type) => ({
+    objectTypeId: type.id,
+    properties: type.properties.filter((property) => property.mode !== "telemetry" && !property.primary).map((property) => {
+      const capabilities = resolvePropertyQueryCapabilities2(property, values);
+      const schema = resolveQuerySchema(property.schema, values);
+      return {
+        propertyId: property.id,
+        scalarKind: schema ? queryScalarKindForSchema(schema) : undefined,
+        filterable: capabilities.operators.includes("eq"),
+        sortable: capabilities.sortable,
+        text: capabilities.text
+      };
+    }).filter((property) => property.filterable || property.sortable || property.text),
+    indexes: type.query?.indexes ?? []
+  }));
+  return input.storage.prepareObjectQueries({ projectId: input.projectId, objectTypes });
+}
+
 // src/storage/migrations/migrate-storage.ts
 function isMigrationCapableStorage2(storage) {
   return Array.isArray(storage.migrators);
 }
-async function migrateStorage2(storage) {
-  if (!isMigrationCapableStorage2(storage) || storage.migrators.length === 0) {
-    return { status: "skipped", reports: [] };
-  }
+async function migrateStorage2(storage, options) {
   const reports = [];
-  for (const migrator of storage.migrators) {
-    reports.push(await migrator.migrate());
+  if (isMigrationCapableStorage2(storage)) {
+    for (const migrator of storage.migrators) {
+      reports.push(await migrator.migrate());
+    }
   }
-  return {
-    status: reports.some((report) => report.status === "migrated") ? "migrated" : "current",
-    reports
-  };
+  let queries;
+  if (options && isQueryPreparationCapableStorage(storage)) {
+    queries = await prepareObjectQueries2({ ...options, storage });
+    for (const warning of queries.warnings) {
+      console.warn(`[Sixb] ${warning}`);
+    }
+  }
+  let status = "skipped";
+  if (reports.length > 0 || queries) {
+    status = "current";
+  }
+  if (reports.some((report) => report.status === "migrated") || queries?.status === "prepared") {
+    status = "migrated";
+  }
+  if (queries)
+    return { status, reports, queries };
+  return { status, reports };
 }
 
 // src/storage/migrations/check-schema.ts
@@ -8635,6 +8994,6 @@ var VECTOR_INDEXING_FAILURE_CODES2 = [
   "vector.outcome_unknown",
   "internal.unexpected"
 ];
-export { InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, InMemoryFileUploadSessions2, hasVectorProfile2, isVectorProfileQuery2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, MAX_VECTOR_K, vectorConfiguration, vectorSources, normalizeVector2, vectorSearchCandidateLimit2, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2, VECTOR_INDEXING_FAILURE_CODES2 };
+export { InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, InMemoryFileUploadSessions2, hasVectorProfile2, isVectorProfileQuery2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, MAX_VECTOR_K, vectorConfiguration, vectorSources, normalizeVector2, vectorSearchCandidateLimit2, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, prepareObjectQueries2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2, VECTOR_INDEXING_FAILURE_CODES2 };
 
-//# debugId=C915DC2D44D0A8AD64756E2164756E21
+//# debugId=06195CF0CDEA109D64756E2164756E21