@sixb/core 0.1.1 → 0.1.3

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,19 +23,24 @@ import {
   type ResolvedLinkValue,
   type ResolvedObjectValue,
   resolveEffectiveLink,
+  resolveEffectiveLinkSlot,
   resolveEffectiveObject,
+  storedObjectEditedAt,
+  usableLinkSlotOverride,
 } from "../effective/resolve"
-import { isKnownLinkRef } from "./read-set"
+import { linkCardinality } from "./read-set"
 export interface WorkingObject {
   ref: OntologyObjectRef
   source: MaterializationObjectState["source"]
   originalOverride: StoredObjectOverride | null
   override: ObjectOverride | null
+  originalEditedAt: Readonly<Record<string, string>>
+  editedAt: Record<string, string>
   before: MaterializationObjectState["effective"]
   latestTelemetry: StoredTelemetryPoint[]
 }
 
-export interface WorkingLink {
+export interface WorkingLinkEdge {
   ref: OntologyLinkRef
   source: MaterializationLinkState["source"]
   originalOverride: StoredLinkOverride | null
@@ -40,41 +48,87 @@ 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 {
+  const editedAt = storedObjectEditedAt(object.override)
   return {
     ref: object.ref,
     source: object.source,
     originalOverride: object.override,
     override: object.override?.value ?? null,
+    originalEditedAt: editedAt,
+    editedAt: { ...editedAt },
     before: object.effective,
     latestTelemetry: [...object.latestTelemetry],
   }
 }
 
-export function workingLinkFromState(link: MaterializationLinkState): WorkingLink {
+export function workingLinkEdgeFromState(link: MaterializationLinkState): WorkingLinkEdge {
   return {
     ref: link.ref,
     source: link.source,
@@ -93,13 +147,14 @@ export function resolveObject(
     primaryPropertyId: ontology.getPrimaryPropertyId(working.ref.objectTypeId),
     source: working.source,
     override: working.override,
+    editedAt: working.editedAt,
     latestTelemetry: working.latestTelemetry,
   })
 }
 
-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 +168,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,17 @@
 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,
+  StoredObjectOverride,
   StoredSourceLinkAssertion,
   StoredSourceObjectAssertion,
   StoredTelemetryPoint,
@@ -21,14 +27,30 @@ 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
   readonly source: StoredSourceObjectAssertion | null
   readonly override: ObjectOverride | null
+  readonly editedAt: Readonly<Record<string, string>>
   readonly latestTelemetry: readonly StoredTelemetryPoint[]
 }): ResolvedObjectValue | null {
-  const properties = resolveObjectAuthority(input.source, input.override)
+  const properties = resolveObjectAuthority(input.source, input.override, input.editedAt)
   if (!properties) return null
 
   properties[input.primaryPropertyId] = input.ref.primaryId
@@ -38,31 +60,98 @@ export function resolveEffectiveObject(input: {
 
 function resolveObjectAuthority(
   source: StoredSourceObjectAssertion | null,
-  override: ObjectOverride | null
+  override: ObjectOverride | null,
+  editedAt: Readonly<Record<string, string>>
 ): Record<string, JsonValue> | null {
   switch (override?.kind) {
     case "delete":
       return null
     case "create":
-      return { ...override.properties }
+      if (!source) return { ...override.properties }
+      return resolveSourceAndEdits(source, override, editedAt)
     case "patch":
       if (!source) return null
-      return applyObjectPatch(source.assertion.properties, override)
+      return resolveSourceAndEdits(source, override, editedAt)
     default:
       if (!source) return null
       return { ...source.assertion.properties }
   }
 }
 
-function applyObjectPatch(
-  sourceProperties: Readonly<Record<string, JsonValue>>,
-  override: Extract<ObjectOverride, { readonly kind: "patch" }>
+function resolveSourceAndEdits(
+  source: StoredSourceObjectAssertion,
+  override: Exclude<ObjectOverride, { readonly kind: "delete" }>,
+  editedAt: Readonly<Record<string, string>>
 ): Record<string, JsonValue> {
-  const properties = { ...sourceProperties, ...override.set }
-  for (const propertyId of override.unset) delete properties[propertyId]
+  const properties = { ...source.assertion.properties }
+  const absentSourcePropertyIds = new Set(source.assertion.absentSourcePropertyIds ?? [])
+
+  for (const propertyId of objectEditCandidateIds(override, editedAt)) {
+    const edit = objectEditCandidate(override, propertyId)
+    const editTimestamp = editedAt[propertyId]
+    const hasSourceCandidate =
+      Object.hasOwn(source.assertion.properties, propertyId) ||
+      absentSourcePropertyIds.has(propertyId)
+    const sourceWins =
+      hasSourceCandidate &&
+      source.assertion.sourceUpdatedAt !== undefined &&
+      editTimestamp !== undefined &&
+      source.assertion.sourceUpdatedAt.localeCompare(editTimestamp) >= 0
+
+    if (!sourceWins) applyObjectEditCandidate(properties, propertyId, edit)
+  }
   return properties
 }
 
+interface ObjectPropertyCandidate {
+  readonly present: boolean
+  readonly value?: JsonValue
+}
+
+function objectEditCandidateIds(
+  override: Exclude<ObjectOverride, { readonly kind: "delete" }>,
+  editedAt: Readonly<Record<string, string>>
+): string[] {
+  const ids = new Set(Object.keys(editedAt))
+  if (override.kind === "create") {
+    for (const propertyId of Object.keys(override.properties)) ids.add(propertyId)
+  } else {
+    for (const propertyId of Object.keys(override.set)) ids.add(propertyId)
+    for (const propertyId of override.unset) ids.add(propertyId)
+  }
+  return [...ids]
+}
+
+function objectEditCandidate(
+  override: Exclude<ObjectOverride, { readonly kind: "delete" }>,
+  propertyId: string
+): ObjectPropertyCandidate {
+  const values = override.kind === "create" ? override.properties : override.set
+  return Object.hasOwn(values, propertyId)
+    ? { present: true, value: values[propertyId] }
+    : { present: false }
+}
+
+function applyObjectEditCandidate(
+  properties: Record<string, JsonValue>,
+  propertyId: string,
+  candidate: ObjectPropertyCandidate
+): void {
+  if (candidate.present) properties[propertyId] = candidate.value as JsonValue
+  else delete properties[propertyId]
+}
+
+export function storedObjectEditedAt(stored: StoredObjectOverride | null): Record<string, string> {
+  if (!stored || stored.value.kind === "delete") return {}
+  const editedAt = { ...(stored.editedAt ?? {}) }
+  const candidateIds =
+    stored.value.kind === "create"
+      ? Object.keys(stored.value.properties)
+      : [...Object.keys(stored.value.set), ...stored.value.unset]
+  for (const propertyId of candidateIds) editedAt[propertyId] ??= stored.updatedAt
+  return editedAt
+}
+
 function applyLatestTelemetry(
   properties: Record<string, JsonValue>,
   latestTelemetry: readonly StoredTelemetryPoint[]
@@ -87,6 +176,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)