@sixb/core 0.1.0 → 0.1.2

package/src/materializer/execution/plan-stream.ts

@@ -6,6 +6,8 @@ import type {
   ExactEffectiveObjectWrite,
   ExactLinkOverrideDelete,
   ExactLinkOverrideWrite,
+  ExactLinkSlotOverrideDelete,
+  ExactLinkSlotOverrideWrite,
   ExactObjectOverrideDelete,
   ExactObjectOverrideWrite,
   ExactTimeseriesPointWrite,
@@ -37,10 +39,20 @@ export async function* planStream(
 
 type MutableChunk = {
   overrides: {
-    objectUpserts: ExactObjectOverrideWrite[]
-    objectDeletes: ExactObjectOverrideDelete[]
-    linkUpserts: ExactLinkOverrideWrite[]
-    linkDeletes: ExactLinkOverrideDelete[]
+    objects: {
+      upserts: ExactObjectOverrideWrite[]
+      deletes: ExactObjectOverrideDelete[]
+    }
+    links: {
+      edges: {
+        upserts: ExactLinkOverrideWrite[]
+        deletes: ExactLinkOverrideDelete[]
+      }
+      slots: {
+        upserts: ExactLinkSlotOverrideWrite[]
+        deletes: ExactLinkSlotOverrideDelete[]
+      }
+    }
   }
   effective: {
     objectUpserts: ExactEffectiveObjectWrite[]
@@ -54,7 +66,13 @@ type MutableChunk = {
 
 function mutableChunk(): MutableChunk {
   return {
-    overrides: { objectUpserts: [], objectDeletes: [], linkUpserts: [], linkDeletes: [] },
+    overrides: {
+      objects: { upserts: [], deletes: [] },
+      links: {
+        edges: { upserts: [], deletes: [] },
+        slots: { upserts: [], deletes: [] },
+      },
+    },
     effective: { objectUpserts: [], objectDeletes: [], linkUpserts: [], linkDeletes: [] },
     timeseries: { pointUpserts: [] },
     outbox: [],
@@ -64,16 +82,22 @@ function mutableChunk(): MutableChunk {
 function appendItem(chunk: MutableChunk, item: MaterializationPlanItem): void {
   switch (item.kind) {
     case "object-override-upsert":
-      chunk.overrides.objectUpserts.push(item.value)
+      chunk.overrides.objects.upserts.push(item.value)
       break
     case "object-override-delete":
-      chunk.overrides.objectDeletes.push(item.value)
+      chunk.overrides.objects.deletes.push(item.value)
       break
     case "link-override-upsert":
-      chunk.overrides.linkUpserts.push(item.value)
+      chunk.overrides.links.edges.upserts.push(item.value)
       break
     case "link-override-delete":
-      chunk.overrides.linkDeletes.push(item.value)
+      chunk.overrides.links.edges.deletes.push(item.value)
+      break
+    case "link-slot-override-upsert":
+      chunk.overrides.links.slots.upserts.push(item.value)
+      break
+    case "link-slot-override-delete":
+      chunk.overrides.links.slots.deletes.push(item.value)
       break
     case "object-upsert":
       chunk.effective.objectUpserts.push(item.value)

package/src/materializer/execution/scope.ts

@@ -0,0 +1,95 @@
+import type { EventActor } from "../../events/envelope"
+import { resolveExecutionScopeAuthorization } from "../../execution/authorization"
+import { ensureExecutionRecord, executionRecordInputFromRuntime } from "../../execution/durable"
+import type { ExecutionScope, TrustedPrimitiveKind } from "../../execution/types"
+import {
+  MaterializationConflictError,
+  MaterializationValidationError,
+} from "../../materialization/errors"
+import type {
+  CreateExecutionInput,
+  ExecutionRecord,
+  ExecutionStorage,
+} from "../../storage/executions"
+
+/** Immutable execution metadata attached to one prepared Materializer command. */
+export interface MaterializerExecution {
+  readonly scope: ExecutionScope
+  readonly record: CreateExecutionInput
+  readonly executionId: string
+  readonly correlationId: string
+  readonly actor?: EventActor
+}
+
+/** Validate the process-local scope before any Materializer read or write is attempted. */
+export function prepareMaterializerExecution(
+  projectId: string,
+  scope: ExecutionScope
+): MaterializerExecution {
+  const authorization = resolveExecutionScopeAuthorization(projectId, scope)
+
+  const base = {
+    scope,
+    record: executionRecordInputFromRuntime({
+      execution: scope.execution,
+      runtimeAuthorization: scope.authorization,
+    }),
+    executionId: scope.execution.id,
+    correlationId: scope.execution.correlationId,
+  }
+  if (authorization.type !== "principal") return base
+  return { ...base, actor: authorization.context.principal }
+}
+
+/** Persist a direct request lazily, or prove that a durable worker restored the exact record. */
+export function ensureMaterializerExecution(
+  executions: ExecutionStorage,
+  execution: MaterializerExecution
+): Promise<ExecutionRecord> {
+  return ensureExecutionRecord(executions, execution.record)
+}
+
+/** Runtime mutations may come from any domain SDK execution except an internal kernel operation. */
+export function assertRuntimeMutationExecution(execution: MaterializerExecution): void {
+  if (execution.scope.execution.executor.type !== "kernel") return
+  throw new MaterializationValidationError(
+    `Kernel execution '${execution.executionId}' cannot enter the runtime mutation boundary.`
+  )
+}
+
+/** Require one internal mutation ingress to belong to its exact trusted primitive run. */
+export function assertTrustedPrimitiveMutationExecution(
+  execution: MaterializerExecution,
+  primitive: {
+    readonly kind: TrustedPrimitiveKind
+    readonly id: string
+    readonly runId: string
+  }
+): void {
+  const executor = execution.scope.execution.executor
+  if (
+    executor.type === "primitive" &&
+    executor.kind === primitive.kind &&
+    executor.id === primitive.id &&
+    executor.runId === primitive.runId
+  ) {
+    return
+  }
+  throw new MaterializationConflictError(
+    "run-correlation",
+    `Execution '${execution.executionId}' does not own ${primitive.kind} run '${primitive.runId}'.`
+  )
+}
+
+/** Require the provider-validated run to reference the same immutable execution as the command. */
+export function assertMaterializerRunExecution(
+  execution: MaterializerExecution,
+  runExecutionId: string,
+  label: string
+): void {
+  if (runExecutionId === execution.executionId) return
+  throw new MaterializationConflictError(
+    "run-correlation",
+    `${label} belongs to execution '${runExecutionId}', not '${execution.executionId}'.`
+  )
+}

package/src/materializer/execution/work-executor.ts

@@ -82,6 +82,7 @@ export async function validateStagedCardinality(
   session: MaterializationSession,
   signal?: AbortSignal
 ): Promise<void> {
+  let currentView: "candidate" | "effective" | null = null
   let currentScope: string | null = null
   let occupant: string | null = null
   for await (const page of storage.streamWork({
@@ -96,14 +97,17 @@ export async function validateStagedCardinality(
           "Provider returned non-cardinality cardinality work."
         )
       }
-      if (record.scopeSortKey !== currentScope) {
+      if (record.view !== currentView || record.scopeSortKey !== currentScope) {
+        currentView = record.view
         currentScope = record.scopeSortKey
         occupant = null
       }
       if (!record.occupied) continue
       if (occupant && occupant !== record.linkSortKey) {
         throw new MaterializationValidationError(
-          `Link scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.`
+          record.view === "candidate"
+            ? `Projection source scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.`
+            : `Link scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.`
         )
       }
       occupant = record.linkSortKey

package/src/materializer/execution/work-records.ts

@@ -10,12 +10,12 @@ import type {
   OntologyOutboxWrite,
 } from "../../storage/ontology"
 import { materializationApplyPhase } from "../../storage/ontology/materializations"
-import type { WorkingLink, WorkingObject } from "../edits/working-state"
+import type { WorkingLinkEdge, WorkingLinkSlot, WorkingObject } from "../edits/working-state"
 import type { OrderedMaterializationEventDraft } from "../effective/build-events"
 import type { TimedCommitIdentity } from "../shared/identity"
 import type { MaterializationPlanItem } from "./plan-stream"
 
-export function appendObjectOverridePlan(
+export function appendObjectOverrideWork(
   items: MaterializationPlanWorkItem[],
   working: WorkingObject,
   identity: TimedCommitIdentity
@@ -45,9 +45,9 @@ export function appendObjectOverridePlan(
   }
 }
 
-export function appendLinkOverridePlan(
+export function appendLinkEdgeOverrideWork(
   items: MaterializationPlanWorkItem[],
-  working: WorkingLink,
+  working: WorkingLinkEdge,
   identity: TimedCommitIdentity
 ): void {
   if (
@@ -75,7 +75,40 @@ export function appendLinkOverridePlan(
   }
 }
 
-export function appendObjectEffectivePlan(
+export function appendLinkSlotOverrideWork(
+  items: MaterializationPlanWorkItem[],
+  working: WorkingLinkSlot,
+  identity: TimedCommitIdentity
+): void {
+  if (
+    stableJsonStringify(working.originalOverride?.value ?? null) ===
+    stableJsonStringify(working.override)
+  ) {
+    return
+  }
+  if (working.override) {
+    items.push({
+      kind: "link-slot-override-upsert",
+      value: {
+        ref: working.ref,
+        value: working.override,
+        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
+        lastCommitId: identity.commitId,
+        updatedAt: identity.committedAt,
+      },
+    })
+  } else if (working.originalOverride) {
+    items.push({
+      kind: "link-slot-override-delete",
+      value: {
+        ref: working.ref,
+        expectedLastCommitId: working.originalOverride.lastCommitId,
+      },
+    })
+  }
+}
+
+export function appendEffectiveObjectWork(
   items: MaterializationPlanWorkItem[],
   change: EffectiveObjectChange
 ): void {
@@ -100,7 +133,7 @@ export function appendObjectEffectivePlan(
   }
 }
 
-export function appendLinkEffectivePlan(
+export function appendEffectiveLinkWork(
   items: MaterializationPlanWorkItem[],
   change: EffectiveLinkChange
 ): void {

package/src/materializer/index.ts

@@ -22,11 +22,13 @@ export type {
   ExpectedLinkScopeRevision,
   ExpectedObjectRevision,
   LinkOverride,
+  LinkSlotOverride,
   MaterializationItemError,
   ObjectOverride,
   OntologyEditCommit,
   OntologyEditOperation,
   OntologyLinkRef,
+  OntologyLinkScopeRef,
   OntologyMaterializationOrigin,
   OntologyMaterializationPropertyChange,
   OntologyMaterializationPropertyChangeMap,
@@ -75,7 +77,13 @@ export {
   computeProjectionRevision,
 } from "../projections/revision"
 export type { ProjectionOwnership, ResolvedProjection } from "../projections/types"
-export type { MaterializerStorage, OntologyMaterializerDependencies } from "./materializer"
+export type {
+  BoundOntologyMaterializer,
+  MaterializerCommand,
+  MaterializerStorage,
+  OntologyMaterializerContract,
+  OntologyMaterializerDependencies,
+} from "./materializer"
 export { createOntologyMaterializer, OntologyMaterializer } from "./materializer"
 export type {
   CommitIdentity,

package/src/materializer/materializer.ts

@@ -1,9 +1,12 @@
+import type { ExecutionScope } from "../execution"
 import type {
+  EditCommitResult,
   OntologyEditCommit,
-  OntologyMaterializer as OntologyMaterializerContract,
+  ProjectionCommitResult,
   ProjectionRunFinishInput,
   ProjectionSourceReplacement,
   TelemetryAppend,
+  TelemetryCommitResult,
 } from "../materialization/model"
 import type { OntologyRegistry } from "../ontology"
 import type { ProjectionRegistry } from "../projections/registry"
@@ -20,13 +23,72 @@ import { appendTelemetry } from "./telemetry/append"
 
 export type { MaterializerStorage, OntologyMaterializerDependencies } from "./context"
 
+export interface MaterializerCommand<TInput> {
+  readonly scope: ExecutionScope
+  readonly input: TInput
+}
+
+export interface OntologyMaterializerContract {
+  withScope(scope: ExecutionScope): BoundOntologyMaterializer
+  readonly edits: {
+    commit(input: MaterializerCommand<OntologyEditCommit>): Promise<EditCommitResult>
+  }
+  readonly projections: {
+    replace(
+      input: MaterializerCommand<ProjectionSourceReplacement>
+    ): Promise<ProjectionCommitResult>
+    finishRun(input: MaterializerCommand<ProjectionRunFinishInput>): Promise<void>
+  }
+  readonly telemetry: {
+    append(input: MaterializerCommand<TelemetryAppend>): Promise<TelemetryCommitResult>
+  }
+}
+
+/** Materializer facade closed over one explicit execution scope. */
+export interface BoundOntologyMaterializer {
+  readonly edits: {
+    commit(input: OntologyEditCommit): Promise<EditCommitResult>
+  }
+  readonly projections: {
+    replace(input: ProjectionSourceReplacement): Promise<ProjectionCommitResult>
+    finishRun(input: ProjectionRunFinishInput): Promise<void>
+  }
+  readonly telemetry: {
+    append(input: TelemetryAppend): Promise<TelemetryCommitResult>
+  }
+}
+
 export class OntologyMaterializer implements OntologyMaterializerContract {
-  readonly edits = { commit: (input: OntologyEditCommit) => commitEdits(this.context, input) }
+  readonly edits = {
+    commit: (command: MaterializerCommand<OntologyEditCommit>) =>
+      commitEdits(this.context, command),
+  }
   readonly projections = {
-    replace: (input: ProjectionSourceReplacement) => replaceProjection(this.context, input),
-    finishRun: (input: ProjectionRunFinishInput) => finishProjectionRun(this.context, input),
+    replace: (command: MaterializerCommand<ProjectionSourceReplacement>) =>
+      replaceProjection(this.context, command),
+    finishRun: (command: MaterializerCommand<ProjectionRunFinishInput>) =>
+      finishProjectionRun(this.context, command),
+  }
+  readonly telemetry = {
+    append: (command: MaterializerCommand<TelemetryAppend>) =>
+      appendTelemetry(this.context, command),
+  }
+
+  withScope(scope: ExecutionScope): BoundOntologyMaterializer {
+    return Object.freeze({
+      edits: Object.freeze({
+        commit: (input: OntologyEditCommit) => this.edits.commit({ scope, input }),
+      }),
+      projections: Object.freeze({
+        replace: (input: ProjectionSourceReplacement) => this.projections.replace({ scope, input }),
+        finishRun: (input: ProjectionRunFinishInput) =>
+          this.projections.finishRun({ scope, input }),
+      }),
+      telemetry: Object.freeze({
+        append: (input: TelemetryAppend) => this.telemetry.append({ scope, input }),
+      }),
+    })
   }
-  readonly telemetry = { append: (input: TelemetryAppend) => appendTelemetry(this.context, input) }
 
   private readonly context: MaterializerContext
 

package/src/materializer/projections/finish-run.ts

@@ -13,6 +13,14 @@ import type { OntologyCommitRecord } from "../../storage/ontology"
 import type { MaterializerContext, MaterializerStorage } from "../context"
 import { withSerializationRetry } from "../execution/commit-lifecycle"
 import { lockProjectionRunForMaterialization } from "../execution/run-correlation"
+import {
+  assertMaterializerRunExecution,
+  assertTrustedPrimitiveMutationExecution,
+  ensureMaterializerExecution,
+  type MaterializerExecution,
+  prepareMaterializerExecution,
+} from "../execution/scope"
+import type { MaterializerCommand } from "../materializer"
 import {
   normalizePinnedDatasetVersion,
   normalizeProjectionExecution,
@@ -26,11 +34,12 @@ interface PreparedProjectionRunFinish {
   readonly identity: ProjectionMaterializationIdentity
   readonly resolved: ResolvedProjection<ProjectionDefinition>
   readonly finishedAt: Date
+  readonly execution: MaterializerExecution
 }
 
 export async function finishProjectionRun(
   context: MaterializerContext,
-  raw: ProjectionRunFinishInput
+  raw: MaterializerCommand<ProjectionRunFinishInput>
 ): Promise<void> {
   const command = prepareProjectionRunFinish(context, raw)
   await withSerializationRetry(context, () =>
@@ -42,14 +51,14 @@ export async function finishProjectionRun(
 
 function prepareProjectionRunFinish(
   context: Pick<MaterializerContext, "projectId" | "projectionRegistry" | "clock">,
-  raw: ProjectionRunFinishInput
+  raw: MaterializerCommand<ProjectionRunFinishInput>
 ): PreparedProjectionRunFinish {
-  assertValidTerminalDecision(raw)
-  const source = normalizeProjectionSourceRef(raw.source)
-  const datasetVersion = normalizePinnedDatasetVersion(raw.datasetVersion)
-  const execution = normalizeProjectionExecution(raw.execution)
+  assertValidTerminalDecision(raw.input)
+  const source = normalizeProjectionSourceRef(raw.input.source)
+  const datasetVersion = normalizePinnedDatasetVersion(raw.input.datasetVersion)
+  const projectionExecution = normalizeProjectionExecution(raw.input.execution)
   const resolved =
-    raw.protocol === "replacement"
+    raw.input.protocol === "replacement"
       ? context.projectionRegistry.resolveSource(source.projectionId)
       : context.projectionRegistry.resolveTelemetry(source.projectionId)
   if (resolved.datasetId !== datasetVersion.datasetId) {
@@ -64,10 +73,11 @@ function prepareProjectionRunFinish(
   })
   return {
     projectId: context.projectId,
-    input: { ...raw, source, datasetVersion, execution },
+    input: { ...raw.input, source, datasetVersion, execution: projectionExecution },
     identity,
     resolved,
-    finishedAt: context.clock(),
+    finishedAt: new Date(raw.input.finishedAt ?? context.clock()),
+    execution: prepareMaterializerExecution(context.projectId, raw.scope),
   }
 }
 
@@ -75,13 +85,20 @@ async function finishProjectionRunTransaction(
   storage: MaterializerStorage,
   command: PreparedProjectionRunFinish
 ): Promise<void> {
-  const { projectionRuns } = await lockProjectionRunForMaterialization(storage, {
+  await ensureMaterializerExecution(storage.executions, command.execution)
+  assertTrustedPrimitiveMutationExecution(command.execution, {
+    kind: "projection",
+    id: command.input.source.projectionId,
+    runId: command.input.execution.projectionRunId,
+  })
+  const { projectionRuns, run } = await lockProjectionRunForMaterialization(storage, {
     projectId: command.projectId,
     projectionRunId: command.input.execution.projectionRunId,
     executionToken: command.input.execution.executionToken,
     identity: command.identity,
     resolved: command.resolved,
   })
+  assertMaterializerRunExecution(command.execution, run.executionId, `Projection run '${run.id}'`)
 
   if (command.input.protocol === "replacement") {
     await assertReplacementTerminalDecision(storage, command)
@@ -123,7 +140,7 @@ function terminalDecision(input: ProjectionRunFinishInput): ProjectionRunTermina
     return {
       protocol: input.protocol,
       status: input.status,
-      ...(input.errorMessage === undefined ? {} : { errorMessage: input.errorMessage }),
+      ...(input.error === undefined ? {} : { error: input.error }),
     }
   }
   if (input.protocol === "telemetry") {
@@ -168,6 +185,7 @@ function assertReplacementCommitCorrelation(
   const { input, identity } = command
   if (
     commit.origin.kind !== "projection" ||
+    commit.executionId !== command.execution.executionId ||
     commit.intent.kind !== "projection" ||
     commit.result.kind !== "projection" ||
     commit.origin.projectionRunId !== input.execution.projectionRunId ||

package/src/materializer/projections/replace.ts

@@ -24,7 +24,15 @@ import type {
 import type { MaterializerContext, MaterializerStorage } from "../context"
 import { replayCommitRecord, withSerializationRetry } from "../execution/commit-lifecycle"
 import { lockProjectionRunForMaterialization } from "../execution/run-correlation"
+import {
+  assertMaterializerRunExecution,
+  assertTrustedPrimitiveMutationExecution,
+  ensureMaterializerExecution,
+  type MaterializerExecution,
+  prepareMaterializerExecution,
+} from "../execution/scope"
 import { drainStagedEvents, drainStagedWork } from "../execution/work-executor"
+import type { MaterializerCommand } from "../materializer"
 import { throwIfAborted } from "../shared/abort"
 import {
   type CommitIdentity,
@@ -58,6 +66,7 @@ interface PreparedProjectionReplacement {
   readonly projectionKind: "object" | "link"
   readonly runIdentity: ProjectionMaterializationIdentity
   readonly identity: CommitIdentity
+  readonly scopeExecution: MaterializerExecution
 }
 
 interface ProjectionCandidate {
@@ -77,15 +86,10 @@ interface ReadyProjectionReplacement extends ProjectionCandidate {
 
 export async function replaceProjection(
   context: MaterializerContext,
-  raw: ProjectionSourceReplacement
+  raw: MaterializerCommand<ProjectionSourceReplacement>
 ): Promise<ProjectionCommitResult> {
   const command = prepareProjectionReplacement(context, raw)
-  await assertProjectionExecution(context.storage, context.projectId, command, {
-    capabilityErrorMessage:
-      "Storage does not provide projection run capabilities required by source replacement.",
-  })
-
-  const replay = await replayProjectionCommit(context, command)
+  const replay = await admitProjectionExecution(context, command)
   if (replay) return replay
 
   const candidate = await prepareProjectionCandidate(context, command)
@@ -100,11 +104,11 @@ export async function replaceProjection(
 
 function prepareProjectionReplacement(
   context: Pick<MaterializerContext, "projectId" | "projectionRegistry">,
-  raw: ProjectionSourceReplacement
+  raw: MaterializerCommand<ProjectionSourceReplacement>
 ): PreparedProjectionReplacement {
-  const source = normalizeProjectionSourceRef(raw.source)
-  const datasetVersion = normalizePinnedDatasetVersion(raw.datasetVersion)
-  const execution = normalizeProjectionExecution(raw.execution)
+  const source = normalizeProjectionSourceRef(raw.input.source)
+  const datasetVersion = normalizePinnedDatasetVersion(raw.input.datasetVersion)
+  const execution = normalizeProjectionExecution(raw.input.execution)
   const resolved = context.projectionRegistry.resolveSource(source.projectionId)
   validateProjectionDataset(resolved, datasetVersion)
 
@@ -123,14 +127,15 @@ function prepareProjectionReplacement(
     source,
     datasetVersion,
     execution,
-    entries: raw.entries,
+    entries: raw.input.entries,
     resolved,
     projectionKind,
     runIdentity,
     identity,
+    scopeExecution: prepareMaterializerExecution(context.projectId, raw.scope),
   }
-  if (raw.signal === undefined) return command
-  return { ...command, signal: raw.signal }
+  if (raw.input.signal === undefined) return command
+  return { ...command, signal: raw.input.signal }
 }
 
 function validateProjectionDataset(
@@ -154,7 +159,12 @@ async function assertProjectionExecution(
   command: PreparedProjectionReplacement,
   options: { readonly capabilityErrorMessage?: string } = {}
 ): Promise<void> {
-  await lockProjectionRunForMaterialization(storage, {
+  assertTrustedPrimitiveMutationExecution(command.scopeExecution, {
+    kind: "projection",
+    id: command.source.projectionId,
+    runId: command.execution.projectionRunId,
+  })
+  const locked = await lockProjectionRunForMaterialization(storage, {
     projectId,
     projectionRunId: command.execution.projectionRunId,
     executionToken: command.execution.executionToken,
@@ -162,19 +172,31 @@ async function assertProjectionExecution(
     resolved: command.resolved,
     ...options,
   })
+  assertMaterializerRunExecution(
+    command.scopeExecution,
+    locked.run.executionId,
+    `Projection run '${locked.run.id}'`
+  )
 }
 
-async function replayProjectionCommit(
+async function admitProjectionExecution(
   context: MaterializerContext,
   command: PreparedProjectionReplacement
 ): Promise<ProjectionCommitResult | null> {
-  const existing = await replayCommitRecord(context, command.identity)
-  if (!existing) return null
   return withSerializationRetry(context, () =>
     context.storage.transaction(
       async (storage) => {
-        await assertProjectionExecution(storage, context.projectId, command)
-        const commit = await replayCommitRecord(context, command.identity, storage)
+        await ensureMaterializerExecution(storage.executions, command.scopeExecution)
+        await assertProjectionExecution(storage, context.projectId, command, {
+          capabilityErrorMessage:
+            "Storage does not provide projection run capabilities required by source replacement.",
+        })
+        const commit = await replayCommitRecord(
+          context,
+          command.identity,
+          command.scopeExecution.executionId,
+          storage
+        )
         return commit ? projectionReplayResult(commit, command) : null
       },
       { isolation: "serializable" }
@@ -280,8 +302,14 @@ async function executeProjectionTransaction(
   command: PreparedProjectionReplacement,
   ready: ReadyProjectionReplacement
 ): Promise<ProjectionCommitResult> {
+  await ensureMaterializerExecution(storage.executions, command.scopeExecution)
   await assertProjectionExecution(storage, context.projectId, command)
-  const replay = await replayCommitRecord(context, command.identity, storage)
+  const replay = await replayCommitRecord(
+    context,
+    command.identity,
+    command.scopeExecution.executionId,
+    storage
+  )
   if (replay) return projectionReplayResult(replay, command)
 
   const origin = projectionOrigin(command)
@@ -362,6 +390,7 @@ function projectionCommit(
     id: identity.commitId,
     idempotencyKey: identity.idempotencyKey,
     requestHash: identity.requestHash,
+    executionId: command.scopeExecution.executionId,
     origin,
     ontologyRevision: command.runIdentity.ontologyRevision,
     projectionRevision: command.runIdentity.projectionRevision,
@@ -385,6 +414,7 @@ async function planReadyProjection(
     projectionKind: command.projectionKind,
     identity: ready.identity,
     origin,
+    correlationId: command.scopeExecution.correlationId,
   }
   if (command.signal === undefined) {
     return planProjectionReplacement(context, storage, session, input)
@@ -435,7 +465,10 @@ async function abandonFailedCandidate(
 function shouldAbandonCandidate(error: unknown): boolean {
   if (error instanceof MaterializationValidationError) return true
   if (error instanceof MaterializationCancellationError) return true
-  return error instanceof MaterializationConflictError && error.kind === "run-correlation"
+  return (
+    error instanceof MaterializationConflictError &&
+    (error.kind === "run-correlation" || error.kind === "idempotency")
+  )
 }
 
 function validateProjectionWatermark(