@sixb/core 0.1.1 → 0.1.3

package/src/storage/ontology/in-memory/materializations.ts

@@ -12,6 +12,7 @@ import type {
 import {
   linkRefKey,
   linkRefSortKey,
+  linkScopeKey,
   linkScopeSortKey,
   objectRefKey,
   objectRefSortKey,
@@ -81,6 +82,7 @@ import {
   linkSnapshot,
   objectSnapshot,
   publicLinkOverride,
+  publicLinkSlotOverride,
   publicObjectOverride,
   storedPoint,
   storedSource,
@@ -182,6 +184,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     private readonly timeseries: InMemoryTimeseriesStorage,
     private readonly getTransactionToken: () => object | null,
     private readonly getMaterializationLifecycle: () => ProviderMaterializationTransactionLifecycle | null,
+    private readonly executionExists: (projectId: string, executionId: string) => Promise<boolean>,
     private readonly hooks: InMemoryOntologyStorageTestHooks = {}
   ) {}
 
@@ -194,6 +197,11 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       )
     }
     assertMaterializationHeader(input)
+    if (!(await this.executionExists(input.commit.projectId, input.commit.executionId))) {
+      throw new MaterializationValidationError(
+        `Ontology commit execution '${input.commit.executionId}' does not exist in project '${input.commit.projectId}'.`
+      )
+    }
     this.assertCommitAbsent(input)
     for (const expected of input.expected.sources)
       this.assertSource(expected, input.commit.projectId)
@@ -435,6 +443,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
               )
             : base.source,
           override: base.override,
+          slotOverride: base.slotOverride,
           effective: base.effective,
           diffRequired: entry.diffRequired,
         })
@@ -565,7 +574,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       apply()
     }
 
-    for (const item of input.chunk.overrides.objectUpserts)
+    for (const item of input.chunk.overrides.objects.upserts)
       write("override.object.upsert", () => {
         const key = projectEntityKey(projectId, objectRefKey(item.ref))
         assertLastCommit(
@@ -579,12 +588,13 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
             projectId,
             ref: item.ref,
             value: item.value,
+            editedAt: { ...item.editedAt },
             lastCommitId: item.lastCommitId,
             updatedAt: item.updatedAt,
           })
         )
       })
-    for (const item of input.chunk.overrides.objectDeletes)
+    for (const item of input.chunk.overrides.objects.deletes)
       write("override.object.delete", () => {
         const key = projectEntityKey(projectId, objectRefKey(item.ref))
         assertLastCommit(
@@ -594,13 +604,13 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
         )
         this.state.objectOverrides.delete(key)
       })
-    for (const item of input.chunk.overrides.linkUpserts)
+    for (const item of input.chunk.overrides.links.edges.upserts)
       write("override.link.upsert", () => {
         const key = projectEntityKey(projectId, linkRefKey(item.ref))
         assertLastCommit(
           this.state.linkOverrides.get(key),
           item.expectedLastCommitId,
-          "link override"
+          "link edge override"
         )
         this.state.linkOverrides.set(
           key,
@@ -613,16 +623,45 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
           })
         )
       })
-    for (const item of input.chunk.overrides.linkDeletes)
+    for (const item of input.chunk.overrides.links.edges.deletes)
       write("override.link.delete", () => {
         const key = projectEntityKey(projectId, linkRefKey(item.ref))
         assertLastCommit(
           this.state.linkOverrides.get(key),
           item.expectedLastCommitId,
-          "link override"
+          "link edge override"
         )
         this.state.linkOverrides.delete(key)
       })
+    for (const item of input.chunk.overrides.links.slots.upserts)
+      write("override.link-slot.upsert", () => {
+        const key = projectEntityKey(projectId, linkScopeKey(item.ref.source, item.ref.linkId))
+        assertLastCommit(
+          this.state.linkSlotOverrides.get(key),
+          item.expectedLastCommitId,
+          "link slot override"
+        )
+        this.state.linkSlotOverrides.set(
+          key,
+          structuredClone({
+            projectId,
+            ref: item.ref,
+            value: item.value,
+            lastCommitId: item.lastCommitId,
+            updatedAt: item.updatedAt,
+          })
+        )
+      })
+    for (const item of input.chunk.overrides.links.slots.deletes)
+      write("override.link-slot.delete", () => {
+        const key = projectEntityKey(projectId, linkScopeKey(item.ref.source, item.ref.linkId))
+        assertLastCommit(
+          this.state.linkSlotOverrides.get(key),
+          item.expectedLastCommitId,
+          "link slot override"
+        )
+        this.state.linkSlotOverrides.delete(key)
+      })
 
     for (const item of input.chunk.effective.linkDeletes)
       write("effective.link.delete", () => {
@@ -693,7 +732,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
           leaseId: null,
           leaseExpiresAt: null,
           publishedAt: null,
-          lastError: null,
+          lastFailure: null,
           createdAt: item.createdAt,
         })
         session.outboxEnvelopes.set(envelope.commitOrdinal, structuredClone(envelope))
@@ -883,6 +922,15 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       if (override.projectId !== projectId) continue
       if (touchesIncident(override.ref)) addReplacementLink(replacement, override.ref, true)
     }
+    for (const override of this.state.linkSlotOverrides.values()) {
+      if (override.projectId !== projectId) continue
+      const ref = {
+        source: override.ref.source,
+        linkId: override.ref.linkId,
+        target: override.value.target,
+      }
+      if (touchesIncident(ref)) addReplacementLink(replacement, ref, true)
+    }
     for (const active of this.state.sourceMaterializations.values()) {
       if (active.projectId !== projectId || active.status !== "active") continue
       for (const row of active.rowsByEntity.values()) {
@@ -898,6 +946,22 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
         addReplacementLink(replacement, ref, false)
       }
     })
+    for (const override of this.state.linkSlotOverrides.values()) {
+      if (
+        override.projectId === projectId &&
+        replacement.affectedScopes.has(linkScopeSortKey(override.ref.source, override.ref.linkId))
+      ) {
+        addReplacementLink(
+          replacement,
+          {
+            source: override.ref.source,
+            linkId: override.ref.linkId,
+            target: override.value.target,
+          },
+          false
+        )
+      }
+    }
     replacement.linksExpanded = true
     replacement.orderedLinks = null
   }
@@ -1061,6 +1125,13 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
           this.state.linkOverrides.get(projectEntityKey(projectId, linkRefKey(ref)))
         )
       ),
+      slotOverride: structuredClone(
+        publicLinkSlotOverride(
+          this.state.linkSlotOverrides.get(
+            projectEntityKey(projectId, linkScopeKey(ref.source, ref.linkId))
+          )
+        )
+      ),
       effective: row ? linkSnapshot(row) : null,
     }
   }
@@ -1095,7 +1166,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     rows.sort((left, right) =>
       linkRefSortKey(linkRef(left)).localeCompare(linkRefSortKey(linkRef(right)))
     )
-    const accumulator = startScopeAccumulator(source, linkId, linkScopeSortKey(source, linkId))
+    const accumulator = startScopeAccumulator(source, linkId)
     for (let offset = 0; offset < rows.length; offset += 1_000) {
       const page = rows.slice(offset, offset + 1_000)
       this.hooks.observeBuffer?.("state.link-scope.page", page.length)
@@ -1103,7 +1174,51 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
         appendScopeSnapshot(accumulator, linkSnapshot(row))
       }
     }
-    return finishScopeAccumulator(accumulator)
+    const effective = rows.length === 1 ? linkSnapshot(rows[0]!) : null
+    return {
+      ...finishScopeAccumulator(accumulator),
+      sourceAssertion: this.findActiveLinkScopeSource(projectId, source, linkId),
+      override: structuredClone(
+        publicLinkSlotOverride(
+          this.state.linkSlotOverrides.get(
+            projectEntityKey(projectId, linkScopeKey(source, linkId))
+          )
+        )
+      ),
+      effective,
+    }
+  }
+
+  private findActiveLinkScopeSource(
+    projectId: string,
+    source: OntologyObjectRef,
+    linkId: string
+  ): StoredSourceLinkAssertion | null {
+    let found: StoredSourceLinkAssertion | null = null
+    for (const active of this.state.sourceMaterializations.values()) {
+      if (active.projectId !== projectId || active.status !== "active") continue
+      for (const row of active.rowsByEntity.values()) {
+        if (
+          row.assertion.kind !== "link" ||
+          objectRefKey(row.assertion.ref.source) !== objectRefKey(source) ||
+          row.assertion.ref.linkId !== linkId
+        ) {
+          continue
+        }
+        if (found) {
+          throw new MaterializationConflictError(
+            "source-materialization",
+            `Multiple active source links assert cardinality-one scope '${source.objectTypeId}.${linkId}'.`
+          )
+        }
+        found = storedSource(
+          active.source.projectionId,
+          active.materializationId,
+          row
+        ) as StoredSourceLinkAssertion
+      }
+    }
+    return structuredClone(found)
   }
 
   private findActiveObjectSource(
@@ -1172,6 +1287,14 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     for (const override of this.state.linkOverrides.values()) {
       if (override.projectId === projectId) consider(override.ref)
     }
+    for (const override of this.state.linkSlotOverrides.values()) {
+      if (override.projectId !== projectId) continue
+      consider({
+        source: override.ref.source,
+        linkId: override.ref.linkId,
+        target: override.value.target,
+      })
+    }
     for (const active of this.state.sourceMaterializations.values()) {
       if (active.projectId !== projectId || active.status !== "active") continue
       for (const row of active.rowsByEntity.values()) {

package/src/storage/ontology/in-memory/outbox.ts

@@ -94,7 +94,7 @@ export class InMemoryOntologyOutboxStorage implements OntologyOutboxStorage {
       this.state.outbox.set(key, {
         ...row,
         availableAt: input.availableAt,
-        lastError: input.error,
+        lastFailure: input.failure === undefined ? row.lastFailure : structuredClone(input.failure),
         leaseId: null,
         leaseExpiresAt: null,
       })

package/src/storage/ontology/in-memory/shared-state.ts

@@ -1,9 +1,13 @@
 import { MaterializationValidationError } from "../../../materialization/errors"
-import type { OntologyMaterializationOrigin } from "../../../materialization/model"
+import type {
+  LinkSlotOverride,
+  OntologyMaterializationOrigin,
+} from "../../../materialization/model"
 import type { OntologyCommitOriginSelector, OntologyCommitRecord } from "../commits"
 import type {
   MaterializationWorkRecord,
   StoredLinkOverride,
+  StoredLinkSlotOverride,
   StoredObjectOverride,
 } from "../materializations"
 import type { OntologyOutboxRecord } from "../outbox"
@@ -23,6 +27,11 @@ export interface InMemoryStoredLinkOverride extends StoredLinkOverride {
   readonly projectId: string
 }
 
+export interface InMemoryStoredLinkSlotOverride extends Omit<StoredLinkSlotOverride, "value"> {
+  readonly projectId: string
+  readonly value: LinkSlotOverride
+}
+
 export interface InMemoryOntologyState {
   readonly commitsById: Map<string, OntologyCommitRecord>
   readonly commitIdByIdempotency: Map<string, string>
@@ -30,6 +39,7 @@ export interface InMemoryOntologyState {
   readonly sourceMaterializations: Map<string, InMemorySourceMaterialization>
   readonly objectOverrides: Map<string, InMemoryStoredObjectOverride>
   readonly linkOverrides: Map<string, InMemoryStoredLinkOverride>
+  readonly linkSlotOverrides: Map<string, InMemoryStoredLinkSlotOverride>
   readonly outbox: Map<string, OntologyOutboxRecord>
 }
 
@@ -49,6 +59,7 @@ export function createInMemoryOntologyState(): InMemoryOntologyState {
     sourceMaterializations: new Map(),
     objectOverrides: new Map(),
     linkOverrides: new Map(),
+    linkSlotOverrides: new Map(),
     outbox: new Map(),
   }
 }

package/src/storage/ontology/index.ts

@@ -29,6 +29,8 @@ export type {
   ExactEffectiveWrites,
   ExactLinkOverrideDelete,
   ExactLinkOverrideWrite,
+  ExactLinkSlotOverrideDelete,
+  ExactLinkSlotOverrideWrite,
   ExactObjectOverrideDelete,
   ExactObjectOverrideWrite,
   ExactOverrideWrites,
@@ -67,6 +69,7 @@ export type {
   SourceReplacementStatePage,
   StageMaterializationWorkInput,
   StoredLinkOverride,
+  StoredLinkSlotOverride,
   StoredObjectOverride,
   StoredTelemetryPoint,
   StreamMaterializationStateInput,
@@ -79,6 +82,8 @@ export type {
   CompleteOntologyOutboxLeaseInput,
   OntologyMaterializationEvent,
   OntologyMaterializationEventDraft,
+  OntologyOutboxFailure,
+  OntologyOutboxFailureCode,
   OntologyOutboxRecord,
   OntologyOutboxStorage,
   OntologyOutboxSummary,
@@ -87,6 +92,7 @@ export type {
   RescheduleOntologyOutboxLeaseInput,
   SummarizeOntologyOutboxInput,
 } from "./outbox"
+export { ONTOLOGY_OUTBOX_FAILURE_CODES } from "./outbox"
 export type {
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,

package/src/storage/ontology/materializations.ts

@@ -7,8 +7,10 @@ import type {
   ExpectedLinkScopeRevision,
   ExpectedObjectRevision,
   LinkOverride,
+  LinkSlotOverride,
   ObjectOverride,
   OntologyLinkRef,
+  OntologyLinkScopeRef,
   OntologyObjectRef,
   PinnedDatasetVersion,
   ProjectionCommitResult,
@@ -24,6 +26,8 @@ import type { StoredSourceLinkAssertion, StoredSourceObjectAssertion } from "./s
 export interface StoredObjectOverride {
   readonly ref: OntologyObjectRef
   readonly value: ObjectOverride
+  /** Per-property Action/runtime edit time. Legacy rows fall back to `updatedAt`. */
+  readonly editedAt?: Readonly<Record<string, string>>
   readonly lastCommitId: string
   readonly updatedAt: string
 }
@@ -35,6 +39,14 @@ export interface StoredLinkOverride {
   readonly updatedAt: string
 }
 
+export interface StoredLinkSlotOverride {
+  readonly ref: OntologyLinkScopeRef
+  /** `legacy-conflict` is migration state and is rejected only when read as cardinality-one. */
+  readonly value: LinkSlotOverride | { readonly kind: "legacy-conflict" }
+  readonly lastCommitId: string
+  readonly updatedAt: string
+}
+
 export interface StoredTelemetryPoint {
   readonly series: TelemetrySeriesRef
   readonly value: JsonValue
@@ -61,12 +73,19 @@ export interface MaterializationLinkState {
   readonly ref: OntologyLinkRef
   readonly source: StoredSourceLinkAssertion | null
   readonly override: StoredLinkOverride | null
+  readonly slotOverride: StoredLinkSlotOverride | null
   readonly effective: EffectiveLinkSnapshot | null
 }
 
 export interface MaterializationLinkScopeState {
   readonly source: OntologyObjectRef
   readonly linkId: string
+  /** Complete active source value for the link slot. */
+  readonly sourceAssertion: StoredSourceLinkAssertion | null
+  /** Managed slot authority; absence delegates to source authority. */
+  readonly override: StoredLinkSlotOverride | null
+  /** The single effective edge, if its endpoints are effective. */
+  readonly effective: EffectiveLinkSnapshot | null
   readonly effectiveCount: number
   readonly fingerprint: string
 }
@@ -143,6 +162,7 @@ export interface MaterializationPlanHeader {
 export interface ExactObjectOverrideWrite {
   readonly ref: OntologyObjectRef
   readonly value: ObjectOverride
+  readonly editedAt: Readonly<Record<string, string>>
   readonly expectedLastCommitId: string | null
   readonly lastCommitId: string
   readonly updatedAt: string
@@ -166,11 +186,34 @@ export interface ExactLinkOverrideDelete {
   readonly expectedLastCommitId: string
 }
 
+export interface ExactLinkSlotOverrideWrite {
+  readonly ref: OntologyLinkScopeRef
+  readonly value: LinkSlotOverride
+  readonly expectedLastCommitId: string | null
+  readonly lastCommitId: string
+  readonly updatedAt: string
+}
+
+export interface ExactLinkSlotOverrideDelete {
+  readonly ref: OntologyLinkScopeRef
+  readonly expectedLastCommitId: string
+}
+
 export interface ExactOverrideWrites {
-  readonly objectUpserts: readonly ExactObjectOverrideWrite[]
-  readonly objectDeletes: readonly ExactObjectOverrideDelete[]
-  readonly linkUpserts: readonly ExactLinkOverrideWrite[]
-  readonly linkDeletes: readonly ExactLinkOverrideDelete[]
+  readonly objects: {
+    readonly upserts: readonly ExactObjectOverrideWrite[]
+    readonly deletes: readonly ExactObjectOverrideDelete[]
+  }
+  readonly links: {
+    readonly edges: {
+      readonly upserts: readonly ExactLinkOverrideWrite[]
+      readonly deletes: readonly ExactLinkOverrideDelete[]
+    }
+    readonly slots: {
+      readonly upserts: readonly ExactLinkSlotOverrideWrite[]
+      readonly deletes: readonly ExactLinkSlotOverrideDelete[]
+    }
+  }
 }
 
 export interface ExactEffectiveObjectWrite {
@@ -289,6 +332,8 @@ export interface MaterializationIncidentObjectWorkRecord {
 export interface MaterializationCardinalityOccupantWorkRecord {
   readonly kind: "cardinality"
   readonly recordKey: string
+  /** Projection candidates are validated independently from the final effective scope. */
+  readonly view: "candidate" | "effective"
   readonly scopeSortKey: string
   readonly linkSortKey: string
   readonly ref: OntologyLinkRef
@@ -300,6 +345,8 @@ export type MaterializationPlanWorkItem =
   | { readonly kind: "object-override-delete"; readonly value: ExactObjectOverrideDelete }
   | { readonly kind: "link-override-upsert"; readonly value: ExactLinkOverrideWrite }
   | { readonly kind: "link-override-delete"; readonly value: ExactLinkOverrideDelete }
+  | { readonly kind: "link-slot-override-upsert"; readonly value: ExactLinkSlotOverrideWrite }
+  | { readonly kind: "link-slot-override-delete"; readonly value: ExactLinkSlotOverrideDelete }
   | { readonly kind: "object-upsert"; readonly value: ExactEffectiveObjectWrite }
   | { readonly kind: "object-delete"; readonly value: ExactEffectiveObjectDelete }
   | { readonly kind: "link-upsert"; readonly value: ExactEffectiveLinkWrite }
@@ -333,6 +380,8 @@ export function materializationApplyPhase(
     case "object-override-delete":
     case "link-override-upsert":
     case "link-override-delete":
+    case "link-slot-override-upsert":
+    case "link-slot-override-delete":
       return 0
     case "point-upsert":
       return 1

package/src/storage/ontology/outbox.ts

@@ -1,3 +1,4 @@
+import type { SixbErrorCode, SixbFailure } from "../../errors/types"
 import type { OntologyMaterializationEvent } from "../../materialization/events"
 
 export type {
@@ -12,6 +13,15 @@ export interface OntologyOutboxWrite {
   readonly createdAt: string
 }
 
+/** Error codes a durable ontology outbox delivery can persist. */
+export const ONTOLOGY_OUTBOX_FAILURE_CODES = ["event.delivery_failed"] as const satisfies readonly [
+  SixbErrorCode,
+  ...SixbErrorCode[],
+]
+
+export type OntologyOutboxFailureCode = (typeof ONTOLOGY_OUTBOX_FAILURE_CODES)[number]
+export type OntologyOutboxFailure = SixbFailure<OntologyOutboxFailureCode>
+
 export interface OntologyOutboxRecord {
   readonly envelope: OntologyMaterializationEvent
   readonly availableAt: string
@@ -19,7 +29,7 @@ export interface OntologyOutboxRecord {
   readonly leaseId: string | null
   readonly leaseExpiresAt: string | null
   readonly publishedAt: string | null
-  readonly lastError: string | null
+  readonly lastFailure: OntologyOutboxFailure | null
   readonly createdAt: string
 }
 
@@ -48,7 +58,8 @@ export interface RescheduleOntologyOutboxLeaseInput {
   readonly ids: readonly string[]
   readonly leaseId: string
   readonly availableAt: string
-  readonly error: string
+  /** The delivery failure that caused this retry. Omitted for lifecycle-only rescheduling. */
+  readonly failure?: OntologyOutboxFailure
 }
 
 export interface PurgePublishedOntologyOutboxInput {

package/src/storage/ontology/provider-header-validation.ts

@@ -35,6 +35,7 @@ function assertCommitEnvelope(commit: OntologyCommitWrite): void {
   assertNonblank(commit.id, "Materialization commit id")
   assertNonblank(commit.idempotencyKey, "Materialization idempotency key")
   assertNonblank(commit.requestHash, "Materialization request hash")
+  assertNonblank(commit.executionId, "Materialization execution id")
   assertNonblank(commit.ontologyRevision, "Materialization ontology revision")
   assertTimestamp(commit.committedAt, "Materialization commit time")
 }

package/src/storage/ontology/provider-work.ts

@@ -32,10 +32,12 @@ export function assertPageRows(value: number): void {
 
 export function materializationChunkRows(chunk: MaterializationPlanChunk): number {
   return (
-    chunk.overrides.objectUpserts.length +
-    chunk.overrides.objectDeletes.length +
-    chunk.overrides.linkUpserts.length +
-    chunk.overrides.linkDeletes.length +
+    chunk.overrides.objects.upserts.length +
+    chunk.overrides.objects.deletes.length +
+    chunk.overrides.links.edges.upserts.length +
+    chunk.overrides.links.edges.deletes.length +
+    chunk.overrides.links.slots.upserts.length +
+    chunk.overrides.links.slots.deletes.length +
     chunk.effective.objectUpserts.length +
     chunk.effective.objectDeletes.length +
     chunk.effective.linkUpserts.length +
@@ -49,22 +51,30 @@ export function materializationPlanItems(
   chunk: MaterializationPlanChunk
 ): MaterializationPlanWorkItem[] {
   return [
-    ...chunk.overrides.objectUpserts.map((value) => ({
+    ...chunk.overrides.objects.upserts.map((value) => ({
       kind: "object-override-upsert" as const,
       value,
     })),
-    ...chunk.overrides.objectDeletes.map((value) => ({
+    ...chunk.overrides.objects.deletes.map((value) => ({
       kind: "object-override-delete" as const,
       value,
     })),
-    ...chunk.overrides.linkUpserts.map((value) => ({
+    ...chunk.overrides.links.edges.upserts.map((value) => ({
       kind: "link-override-upsert" as const,
       value,
     })),
-    ...chunk.overrides.linkDeletes.map((value) => ({
+    ...chunk.overrides.links.edges.deletes.map((value) => ({
       kind: "link-override-delete" as const,
       value,
     })),
+    ...chunk.overrides.links.slots.upserts.map((value) => ({
+      kind: "link-slot-override-upsert" as const,
+      value,
+    })),
+    ...chunk.overrides.links.slots.deletes.map((value) => ({
+      kind: "link-slot-override-delete" as const,
+      value,
+    })),
     ...chunk.effective.linkDeletes.map((value) => ({ kind: "link-delete" as const, value })),
     ...chunk.effective.objectDeletes.map((value) => ({ kind: "object-delete" as const, value })),
     ...chunk.effective.objectUpserts.map((value) => ({ kind: "object-upsert" as const, value })),
@@ -129,7 +139,7 @@ export function workUniquenessKey(record: MaterializationWorkRecord): string {
     case "incident-object":
       return `incident-object:${objectRefKey(record.ref)}`
     case "cardinality":
-      return `cardinality:${record.scopeSortKey}:${record.linkSortKey}`
+      return `cardinality:${record.view}:${record.scopeSortKey}:${record.linkSortKey}`
     case "plan":
       return `plan:${record.item.kind}:${record.sortKey}`
     case "event":
@@ -159,16 +169,20 @@ function planKindOrder(kind: MaterializationPlanWorkItem["kind"]): number {
       return 2
     case "link-override-delete":
       return 3
-    case "point-upsert":
+    case "link-slot-override-upsert":
       return 4
-    case "link-delete":
+    case "link-slot-override-delete":
       return 5
-    case "object-delete":
+    case "point-upsert":
       return 6
-    case "object-upsert":
+    case "link-delete":
       return 7
-    case "link-upsert":
+    case "object-delete":
       return 8
+    case "object-upsert":
+      return 9
+    case "link-upsert":
+      return 10
   }
 }
 
@@ -177,12 +191,17 @@ export function compareCardinalityWork(
   right: MaterializationCardinalityOccupantWorkRecord
 ): number {
   return (
+    cardinalityViewOrder(left.view) - cardinalityViewOrder(right.view) ||
     left.scopeSortKey.localeCompare(right.scopeSortKey) ||
     left.linkSortKey.localeCompare(right.linkSortKey) ||
     left.recordKey.localeCompare(right.recordKey)
   )
 }
 
+function cardinalityViewOrder(view: MaterializationCardinalityOccupantWorkRecord["view"]): number {
+  return view === "effective" ? 0 : 1
+}
+
 export function compareEventWork(
   left: MaterializationEventWorkRecord,
   right: MaterializationEventWorkRecord