@sixb/core 0.1.1 → 0.1.2

package/src/materializer/effective/load-state.ts

@@ -1,4 +1,3 @@
-import type { OntologyEditOperation } from "../../materialization/model"
 import type {
   MaterializationLinkScopeState,
   MaterializationLinkState,
@@ -18,36 +17,6 @@ interface MutableStatePage {
   points: StoredTelemetryPoint[]
 }
 
-export function stateRequestForOperation(
-  operation: OntologyEditOperation
-): MaterializationStateRequestChunk {
-  switch (operation.kind) {
-    case "object.create":
-    case "object.upsert":
-    case "object.patch":
-    case "object.delete":
-    case "object.restore":
-      return {
-        objects: [operation.ref],
-        links: [],
-        linkScopes: [],
-        // Incident authority is needed only when the ordered operation changes effective presence.
-        incidentObjects: [],
-        points: [],
-      }
-    case "link.upsert":
-    case "link.delete":
-    case "link.reset":
-      return {
-        objects: [operation.ref.source, operation.ref.target],
-        links: [operation.ref],
-        linkScopes: [{ source: operation.ref.source, linkId: operation.ref.linkId }],
-        incidentObjects: [],
-        points: [],
-      }
-  }
-}
-
 export async function* oneStateRequest(
   request: MaterializationStateRequestChunk
 ): AsyncIterable<MaterializationStateRequestChunk> {

package/src/materializer/effective/resolve.ts

@@ -1,11 +1,16 @@
 import type { JsonValue } from "../../json"
+import { MaterializationConflictError } from "../../materialization/errors"
 import type {
   LinkOverride,
+  LinkSlotOverride,
   ObjectOverride,
   OntologyLinkRef,
+  OntologyLinkScopeRef,
   OntologyObjectRef,
 } from "../../materialization/model"
+import { linkRefKey } from "../../materialization/refs"
 import type {
+  StoredLinkSlotOverride,
   StoredSourceLinkAssertion,
   StoredSourceObjectAssertion,
   StoredTelemetryPoint,
@@ -21,6 +26,21 @@ export interface ResolvedLinkValue {
   readonly properties?: Readonly<Record<string, JsonValue>>
 }
 
+export function usableLinkSlotOverride(
+  stored: StoredLinkSlotOverride | null
+): LinkSlotOverride | null {
+  if (!stored) return null
+  if (stored.value.kind !== "legacy-conflict") return stored.value
+  const { source, linkId } = stored.ref
+  const scopeLabel = JSON.stringify([source.objectTypeId, source.primaryId, linkId])
+  throw new MaterializationConflictError(
+    "effective-state",
+    `Cardinality-one link slot ${scopeLabel} could not be migrated automatically because it ` +
+      "contains multiple legacy upsert overrides. Consolidate the stored overrides and clear " +
+      "the migration conflict marker before materializing this scope."
+  )
+}
+
 export function resolveEffectiveObject(input: {
   readonly ref: OntologyObjectRef
   readonly primaryPropertyId: string
@@ -87,6 +107,48 @@ export function resolveEffectiveLink(input: {
   return resolvedLink(input.ref, input.source.assertion.properties)
 }
 
+/** Resolves the effective edge selected by a cardinality-one link slot. */
+export function resolveEffectiveLinkSlot(input: {
+  readonly scope: OntologyLinkScopeRef
+  readonly source: StoredSourceLinkAssertion | null
+  readonly override: LinkSlotOverride | null
+  readonly endpointExists: (ref: OntologyObjectRef) => boolean
+}): ResolvedLinkValue | null {
+  if (!input.endpointExists(input.scope.source)) return null
+  if (input.override?.kind === "clear") return null
+
+  if (input.override?.kind === "set") {
+    if (!input.endpointExists(input.override.target)) return null
+    return resolvedLink(
+      {
+        source: input.scope.source,
+        linkId: input.scope.linkId,
+        target: input.override.target,
+      },
+      input.override.properties
+    )
+  }
+
+  if (!input.source || !input.endpointExists(input.source.assertion.ref.target)) return null
+  return resolvedLink(input.source.assertion.ref, input.source.assertion.properties)
+}
+
+/** Resolves one exact edge as a member of its cardinality-one link slot. */
+export function resolveEffectiveLinkSlotMember(input: {
+  readonly ref: OntologyLinkRef
+  readonly source: StoredSourceLinkAssertion | null
+  readonly override: LinkSlotOverride | null
+  readonly endpointExists: (ref: OntologyObjectRef) => boolean
+}): ResolvedLinkValue | null {
+  const resolved = resolveEffectiveLinkSlot({
+    scope: { source: input.ref.source, linkId: input.ref.linkId },
+    source: input.source,
+    override: input.override,
+    endpointExists: input.endpointExists,
+  })
+  return resolved && linkRefKey(resolved.ref) === linkRefKey(input.ref) ? resolved : null
+}
+
 function resolvedLink(
   ref: OntologyLinkRef,
   properties: Readonly<Record<string, JsonValue>> | undefined

package/src/materializer/execution/commit-lifecycle.ts

@@ -12,6 +12,7 @@ import type { CommitIdentity } from "../shared/identity"
 export async function replayCommitRecord(
   context: Pick<MaterializerContext, "projectId" | "storage">,
   identity: CommitIdentity,
+  executionId: string,
   storage: MaterializerStorage = context.storage
 ): Promise<OntologyCommitRecord | null> {
   const existing = await storage.ontology.commits.getByIdempotencyKey({
@@ -25,6 +26,12 @@ export async function replayCommitRecord(
       `Idempotency key '${identity.idempotencyKey}' was reused with different intent.`
     )
   }
+  if (existing.executionId !== executionId) {
+    throw new MaterializationConflictError(
+      "idempotency",
+      `Idempotency key '${identity.idempotencyKey}' belongs to execution '${existing.executionId}', not '${executionId}'.`
+    )
+  }
   return existing
 }
 
@@ -33,9 +40,10 @@ export async function replayCommit<
 >(
   context: Pick<MaterializerContext, "projectId" | "storage">,
   identity: CommitIdentity,
+  executionId: string,
   storage: MaterializerStorage = context.storage
 ): Promise<TResult | null> {
-  const existing = await replayCommitRecord(context, identity, storage)
+  const existing = await replayCommitRecord(context, identity, executionId, storage)
   if (!existing) return null
   return { ...structuredClone(existing.result), created: false } as TResult
 }

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 ||