@sixb/core 0.1.0 → 0.1.2

package/src/materializer/edits/plan.ts

@@ -9,6 +9,8 @@ import {
   compareObjectRefs,
   linkRefKey,
   linkRefSortKey,
+  linkScopeKey,
+  linkScopeSortKey,
   objectRefKey,
   objectRefSortKey,
 } from "../../materialization/refs"
@@ -23,25 +25,28 @@ import {
   buildLinkMaterializationEventDraft,
   buildObjectMaterializationEventDraft,
 } from "../effective/build-events"
-import { diffEffectiveLink, diffEffectiveObject } from "../effective/diff"
+import { diffEffectiveLink, diffEffectiveLinkSlot, diffEffectiveObject } from "../effective/diff"
 import { validateEffectiveObject } from "../effective/validate"
 import { stageWorkBounded } from "../execution/work-executor"
 import {
-  appendLinkEffectivePlan,
-  appendLinkOverridePlan,
-  appendObjectEffectivePlan,
-  appendObjectOverridePlan,
+  appendEffectiveLinkWork,
+  appendEffectiveObjectWork,
+  appendLinkEdgeOverrideWork,
+  appendLinkSlotOverrideWork,
+  appendObjectOverrideWork,
   classificationWork,
   eventWork,
   planWork,
 } from "../execution/work-records"
 import type { TimedCommitIdentity } from "../shared/identity"
-import type { EditWorkingState } from "./operations"
 import {
-  resolveLink,
+  type EditWorkingState,
+  resolveLinkEdge,
+  resolveLinkSlot,
   resolveObject,
   validateWorkingCardinality,
-  type WorkingLink,
+  type WorkingLinkEdge,
+  type WorkingLinkSlot,
   type WorkingObject,
 } from "./working-state"
 
@@ -53,6 +58,7 @@ export interface EditPlanChanges {
 interface EditPlanContext {
   readonly identity: TimedCommitIdentity
   readonly origin: OntologyMaterializationOrigin
+  readonly correlationId: string
   readonly actor?: EventActor
 }
 
@@ -63,17 +69,17 @@ export async function stageEditPlan(
   state: EditWorkingState,
   planContext: EditPlanContext
 ): Promise<EditPlanChanges> {
-  validateWorkingCardinality(context.ontology, state.objects, state.links, state.scopeSnapshots)
+  validateWorkingCardinality(state.links.slots)
 
   const objectChanges: EffectiveObjectChange[] = []
   for (const working of sortedObjects(state.objects)) {
-    const change = await stageObjectPlan(context, storage, session, working, planContext)
+    const change = await stageObject(context, storage, session, working, planContext)
     if (change) objectChanges.push(change)
   }
 
   const linkChanges: EffectiveLinkChange[] = []
-  for (const working of sortedLinks(state.links)) {
-    const change = await stageLinkPlan(
+  for (const working of sortedLinkEdges(state.links.edges)) {
+    const change = await stageLinkEdge(
       context,
       storage,
       session,
@@ -83,11 +89,69 @@ export async function stageEditPlan(
     )
     if (change) linkChanges.push(change)
   }
+  for (const working of sortedLinkSlots(state.links.slots)) {
+    linkChanges.push(
+      ...(await stageLinkSlot(context, storage, session, state.objects, working, planContext))
+    )
+  }
 
   return { objects: objectChanges, links: linkChanges }
 }
 
-async function stageObjectPlan(
+/**
+ * Stages one slot-level authority change and translates it back to physical edge writes/events.
+ * Replacing the selected target therefore becomes an ordered delete of the old edge followed by a
+ * create of the new edge, while the override itself remains keyed only by `(source, linkId)`.
+ */
+async function stageLinkSlot(
+  context: MaterializerContext,
+  storage: OntologyMaterializationStorage,
+  session: MaterializationSession,
+  objects: EditWorkingState["objects"],
+  working: WorkingLinkSlot,
+  planContext: EditPlanContext
+): Promise<EffectiveLinkChange[]> {
+  const overrideItems: MaterializationPlanWorkItem[] = []
+  appendLinkSlotOverrideWork(overrideItems, working, planContext.identity)
+  const resolved = resolveLinkSlot(context.ontology, working, objects)
+  const changes = diffEffectiveLinkSlot({
+    before: working.before,
+    resolved,
+    commitId: planContext.identity.commitId,
+    committedAt: planContext.identity.committedAt,
+  })
+
+  const representative =
+    resolved?.ref ??
+    working.before?.ref ??
+    (working.override
+      ? {
+          source: working.ref.source,
+          linkId: working.ref.linkId,
+          target: working.override.target,
+        }
+      : null)
+  const scopeSortKey = linkScopeSortKey(working.ref.source, working.ref.linkId)
+  const work: MaterializationWorkRecord[] = overrideItems.map((item) =>
+    planWork(item, scopeSortKey)
+  )
+  if (representative) {
+    work.push(
+      classificationWork("link", linkRefKey(representative), linkRefSortKey(representative))
+    )
+  }
+  for (const change of changes) {
+    const effectiveItems: MaterializationPlanWorkItem[] = []
+    appendEffectiveLinkWork(effectiveItems, change)
+    const sortKey = linkRefSortKey(change.ref)
+    work.push(...effectiveItems.map((item) => planWork(item, sortKey)))
+    work.push(eventWork(buildLinkEvent(context, planContext, change)))
+  }
+  await stageWorkBounded(context, storage, session, work)
+  return changes
+}
+
+async function stageObject(
   context: MaterializerContext,
   storage: OntologyMaterializationStorage,
   session: MaterializationSession,
@@ -95,7 +159,7 @@ async function stageObjectPlan(
   planContext: EditPlanContext
 ): Promise<EffectiveObjectChange | null> {
   const items: MaterializationPlanWorkItem[] = []
-  appendObjectOverridePlan(items, working, planContext.identity)
+  appendObjectOverrideWork(items, working, planContext.identity)
 
   const resolved = resolveObject(context.ontology, working)
   if (resolved) validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
@@ -105,7 +169,7 @@ async function stageObjectPlan(
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt,
   })
-  if (change) appendObjectEffectivePlan(items, change)
+  if (change) appendEffectiveObjectWork(items, change)
 
   const sortKey = objectRefSortKey(working.ref)
   const work: MaterializationWorkRecord[] = [
@@ -119,25 +183,25 @@ async function stageObjectPlan(
   return change
 }
 
-async function stageLinkPlan(
+async function stageLinkEdge(
   context: MaterializerContext,
   storage: OntologyMaterializationStorage,
   session: MaterializationSession,
   objects: EditWorkingState["objects"],
-  working: WorkingLink,
+  working: WorkingLinkEdge,
   planContext: EditPlanContext
 ): Promise<EffectiveLinkChange | null> {
   const items: MaterializationPlanWorkItem[] = []
-  appendLinkOverridePlan(items, working, planContext.identity)
+  appendLinkEdgeOverrideWork(items, working, planContext.identity)
 
-  const resolved = resolveLink(context.ontology, working, objects)
+  const resolved = resolveLinkEdge(context.ontology, working, objects)
   const change = diffEffectiveLink({
     before: working.before,
     resolved,
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt,
   })
-  if (change) appendLinkEffectivePlan(items, change)
+  if (change) appendEffectiveLinkWork(items, change)
 
   const sortKey = linkRefSortKey(working.ref)
   const work: MaterializationWorkRecord[] = [
@@ -178,6 +242,7 @@ function materializationEventContext(
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt,
     origin: planContext.origin,
+    correlationId: planContext.correlationId,
   }
   if (planContext.actor === undefined) return base
   return { ...base, actor: planContext.actor }
@@ -187,6 +252,14 @@ function sortedObjects(objects: EditWorkingState["objects"]): WorkingObject[] {
   return [...objects.values()].sort((left, right) => compareObjectRefs(left.ref, right.ref))
 }
 
-function sortedLinks(links: EditWorkingState["links"]): WorkingLink[] {
-  return [...links.values()].sort((left, right) => compareLinkRefs(left.ref, right.ref))
+function sortedLinkEdges(edges: EditWorkingState["links"]["edges"]): WorkingLinkEdge[] {
+  return [...edges.values()].sort((left, right) => compareLinkRefs(left.ref, right.ref))
+}
+
+function sortedLinkSlots(slots: EditWorkingState["links"]["slots"]): WorkingLinkSlot[] {
+  return [...slots.values()].sort((left, right) =>
+    linkScopeKey(left.ref.source, left.ref.linkId).localeCompare(
+      linkScopeKey(right.ref.source, right.ref.linkId)
+    )
+  )
 }

package/src/materializer/edits/working-state.ts

@@ -1,8 +1,10 @@
 import { MaterializationValidationError } from "../../materialization/errors"
 import type {
   LinkOverride,
+  LinkSlotOverride,
   ObjectOverride,
   OntologyLinkRef,
+  OntologyLinkScopeRef,
   OntologyObjectRef,
 } from "../../materialization/model"
 import { linkRefKey, linkScopeKey, objectRefKey } from "../../materialization/refs"
@@ -13,6 +15,7 @@ import type {
   MaterializationObjectState,
   MaterializationStatePage,
   StoredLinkOverride,
+  StoredLinkSlotOverride,
   StoredObjectOverride,
   StoredTelemetryPoint,
 } from "../../storage/ontology"
@@ -20,9 +23,11 @@ import {
   type ResolvedLinkValue,
   type ResolvedObjectValue,
   resolveEffectiveLink,
+  resolveEffectiveLinkSlot,
   resolveEffectiveObject,
+  usableLinkSlotOverride,
 } from "../effective/resolve"
-import { isKnownLinkRef } from "./read-set"
+import { linkCardinality } from "./read-set"
 export interface WorkingObject {
   ref: OntologyObjectRef
   source: MaterializationObjectState["source"]
@@ -32,7 +37,7 @@ export interface WorkingObject {
   latestTelemetry: StoredTelemetryPoint[]
 }
 
-export interface WorkingLink {
+export interface WorkingLinkEdge {
   ref: OntologyLinkRef
   source: MaterializationLinkState["source"]
   originalOverride: StoredLinkOverride | null
@@ -40,29 +45,72 @@ export interface WorkingLink {
   before: MaterializationLinkState["effective"]
 }
 
+export interface WorkingLinkSlot {
+  readonly ref: OntologyLinkScopeRef
+  readonly source: MaterializationLinkScopeState["sourceAssertion"]
+  readonly originalOverride: StoredLinkSlotOverride | null
+  override: LinkSlotOverride | null
+  readonly before: MaterializationLinkScopeState["effective"]
+  readonly effectiveCount: number
+}
+
+/**
+ * Transaction-local edit working set.
+ *
+ * Loaded snapshots remain pinned to the commit start while each successful operation updates the
+ * mutable override. Operation N+1 can therefore observe operation N before anything is durable.
+ */
+export interface EditWorkingState {
+  readonly objects: Map<string, WorkingObject>
+  /**
+   * Link authorities use two identity grains:
+   * - edges are keyed by `(source, linkId, target)` for cardinality-many links;
+   * - slots are keyed by `(source, linkId)` and select at most one target for
+   *   cardinality-one links.
+   */
+  readonly links: {
+    readonly edges: Map<string, WorkingLinkEdge>
+    readonly slots: Map<string, WorkingLinkSlot>
+  }
+}
+
 export function mergeWorkingState(
-  objects: Map<string, WorkingObject>,
-  links: Map<string, WorkingLink>,
-  scopes: Map<string, MaterializationLinkScopeState>,
+  ontology: OntologyRegistry,
+  working: EditWorkingState,
   state: MaterializationStatePage
 ): void {
   for (const object of state.objects) {
-    if (!objects.has(objectRefKey(object.ref))) {
-      objects.set(objectRefKey(object.ref), workingObjectFromState(object))
+    if (!working.objects.has(objectRefKey(object.ref))) {
+      working.objects.set(objectRefKey(object.ref), workingObjectFromState(object))
     }
   }
   for (const link of state.links) {
-    if (!links.has(linkRefKey(link.ref))) {
-      links.set(linkRefKey(link.ref), workingLinkFromState(link))
+    if (
+      linkCardinality(ontology, link.ref) !== "one" &&
+      !working.links.edges.has(linkRefKey(link.ref))
+    ) {
+      working.links.edges.set(linkRefKey(link.ref), workingLinkEdgeFromState(link))
     }
   }
   for (const scope of state.linkScopes) {
-    if (!scopes.has(linkScopeKey(scope.source, scope.linkId))) {
-      scopes.set(linkScopeKey(scope.source, scope.linkId), scope)
+    const key = linkScopeKey(scope.source, scope.linkId)
+    if (!working.links.slots.has(key)) {
+      working.links.slots.set(key, workingLinkSlotFromState(scope))
     }
   }
 }
 
+function workingLinkSlotFromState(scope: MaterializationLinkScopeState): WorkingLinkSlot {
+  return {
+    ref: { source: scope.source, linkId: scope.linkId },
+    source: scope.sourceAssertion,
+    originalOverride: scope.override,
+    override: usableLinkSlotOverride(scope.override),
+    before: scope.effective,
+    effectiveCount: scope.effectiveCount,
+  }
+}
+
 export function workingObjectFromState(object: MaterializationObjectState): WorkingObject {
   return {
     ref: object.ref,
@@ -74,7 +122,7 @@ export function workingObjectFromState(object: MaterializationObjectState): Work
   }
 }
 
-export function workingLinkFromState(link: MaterializationLinkState): WorkingLink {
+export function workingLinkEdgeFromState(link: MaterializationLinkState): WorkingLinkEdge {
   return {
     ref: link.ref,
     source: link.source,
@@ -97,9 +145,9 @@ export function resolveObject(
   })
 }
 
-export function resolveLink(
+export function resolveLinkEdge(
   ontology: OntologyRegistry,
-  working: WorkingLink,
+  working: WorkingLinkEdge,
   objects: Map<string, WorkingObject>
 ): ResolvedLinkValue | null {
   const source = objects.get(objectRefKey(working.ref.source))
@@ -113,59 +161,42 @@ export function resolveLink(
   })
 }
 
+export function resolveLinkSlot(
+  ontology: OntologyRegistry,
+  working: WorkingLinkSlot,
+  objects: Map<string, WorkingObject>
+): ResolvedLinkValue | null {
+  return resolveEffectiveLinkSlot({
+    scope: working.ref,
+    source: working.source,
+    override: working.override,
+    endpointExists: (ref) => {
+      const object = objects.get(objectRefKey(ref))
+      return Boolean(object && resolveObject(ontology, object))
+    },
+  })
+}
+
 export function distinctCardinalityOneScopes(
   ontology: OntologyRegistry,
   links: readonly MaterializationLinkState[],
-  existing: Map<string, MaterializationLinkScopeState>
+  existing: ReadonlyMap<string, WorkingLinkSlot>
 ): { readonly source: OntologyObjectRef; readonly linkId: string }[] {
   const scopes = new Map<string, { readonly source: OntologyObjectRef; readonly linkId: string }>()
   for (const state of links) {
-    const definition = ontology
-      .resolveObjectType(state.ref.source.objectTypeId)
-      .links.find((candidate) => candidate.id === state.ref.linkId)
     const key = linkScopeKey(state.ref.source, state.ref.linkId)
-    if (definition?.cardinality === "one" && !existing.has(key)) {
+    if (linkCardinality(ontology, state.ref) === "one" && !existing.has(key)) {
       scopes.set(key, { source: state.ref.source, linkId: state.ref.linkId })
     }
   }
   return [...scopes.values()]
 }
 
-export function validateWorkingCardinality(
-  ontology: OntologyRegistry,
-  objects: Map<string, WorkingObject>,
-  links: Map<string, WorkingLink>,
-  scopes: Map<string, MaterializationLinkScopeState>
-): void {
-  const effectiveByScope = new Map<
-    string,
-    { count: number; source: OntologyObjectRef; linkId: string }
-  >()
-  for (const [scope, snapshot] of scopes) {
-    effectiveByScope.set(scope, {
-      count: snapshot.effectiveCount,
-      source: snapshot.source,
-      linkId: snapshot.linkId,
-    })
-  }
-  for (const working of links.values()) {
-    if (!isKnownLinkRef(ontology, working.ref)) continue
-    const scope = linkScopeKey(working.ref.source, working.ref.linkId)
-    const state = effectiveByScope.get(scope)
-    if (!state) continue
-    const before = working.before ? 1 : 0
-    const after = resolveLink(ontology, working, objects) ? 1 : 0
-    state.count += after - before
-  }
-  for (const { count, source, linkId } of effectiveByScope.values()) {
-    if (count <= 1) continue
-    const link = ontology
-      .resolveObjectType(source.objectTypeId)
-      .links.find((candidate) => candidate.id === linkId)
-    if (link?.cardinality === "one") {
-      throw new MaterializationValidationError(
-        `Link scope '${source.objectTypeId}.${linkId}' has cardinality one.`
-      )
-    }
+export function validateWorkingCardinality(slots: ReadonlyMap<string, WorkingLinkSlot>): void {
+  for (const { effectiveCount, ref } of slots.values()) {
+    if (effectiveCount <= 1) continue
+    throw new MaterializationValidationError(
+      `Link scope '${ref.source.objectTypeId}.${ref.linkId}' has cardinality one.`
+    )
   }
 }

package/src/materializer/effective/build-events.ts

@@ -22,6 +22,7 @@ export interface MaterializationEventDraftContext {
   readonly projectId: string
   readonly commitId: string
   readonly committedAt: string
+  readonly correlationId: string
   readonly origin: OntologyMaterializationOrigin
   readonly actor?: EventActor
 }
@@ -165,6 +166,7 @@ function eventDraftBase(context: MaterializationEventDraftContext) {
     schemaVersion: 1 as const,
     projectId: context.projectId,
     occurredAt: context.committedAt,
+    correlationId: context.correlationId,
     origin: context.origin,
     commitId: context.commitId,
   }

package/src/materializer/effective/diff.ts

@@ -6,6 +6,7 @@ import type {
   EffectiveObjectSnapshot,
   OntologyMaterializationPropertyChangeMap,
 } from "../../materialization/model"
+import { linkRefKey } from "../../materialization/refs"
 import type { ResolvedLinkValue, ResolvedObjectValue } from "./resolve"
 
 export function diffEffectiveObject(input: {
@@ -91,6 +92,27 @@ export function diffEffectiveLink(input: {
   return updateLinkChange(input.before, input.resolved, input.commitId, input.committedAt)
 }
 
+/** Diffs a cardinality-one value slot while preserving edge identity at the physical boundary. */
+export function diffEffectiveLinkSlot(input: {
+  readonly before: EffectiveLinkSnapshot | null
+  readonly resolved: ResolvedLinkValue | null
+  readonly commitId: string
+  readonly committedAt: string
+}): EffectiveLinkChange[] {
+  if (
+    input.before &&
+    input.resolved &&
+    linkRefKey(input.before.ref) !== linkRefKey(input.resolved.ref)
+  ) {
+    return [
+      diffEffectiveLink({ ...input, resolved: null })!,
+      diffEffectiveLink({ ...input, before: null })!,
+    ]
+  }
+  const change = diffEffectiveLink(input)
+  return change ? [change] : []
+}
+
 function createLinkChange(
   resolved: ResolvedLinkValue,
   commitId: string,

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
 }