@sixb/core 0.1.8 → 0.1.10

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

@@ -86,7 +86,6 @@ import {
   publicLinkSlotOverride,
   publicObjectOverride,
   storedPoint,
-  storedSource,
   storedSourceLink,
   storedSourceObject,
   uniqueBy,
@@ -117,6 +116,7 @@ import {
   projectEntityKey,
   sourceMaterializationKey,
 } from "./shared-state"
+import { activateSourceRoots, previousSourceRows } from "./source-roots"
 
 export interface SessionState {
   readonly providerToken: object
@@ -160,7 +160,7 @@ export interface ReplacementLinkWork {
 export interface ReplacementSessionState {
   readonly sourceId: string
   readonly candidateMaterializationId: string
-  readonly previous: InMemorySourceMaterialization | undefined
+  readonly owned: Set<string>
   readonly candidate: InMemorySourceMaterialization
   readonly objects: Map<string, ReplacementObjectWork>
   readonly links: Map<string, ReplacementLinkWork>
@@ -432,8 +432,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       for (const entry of selected) {
         const key = projectionEntityKey({ kind: "link", ref: entry.ref })
         const base = await this.linkState(session, entry.ref)
-        const ownedByReplacement =
-          replacement.previous?.rowsByEntity.has(key) || replacement.candidate.rowsByEntity.has(key)
+        const ownedByReplacement = replacement.owned.has(key)
         links.push({
           ref: base.ref,
           candidateSource: ownedByReplacement
@@ -788,6 +787,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
           }
         )
       }
+      activateSourceRoots(this.state, candidate, activation)
       this.state.sourceMaterializations.set(candidateKey, {
         ...candidate,
         status: "active",
@@ -872,7 +872,7 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     const replacement: ReplacementSessionState = {
       sourceId,
       candidateMaterializationId: input.candidateMaterializationId,
-      previous,
+      owned: new Set(),
       candidate,
       objects: new Map(),
       links: new Map(),
@@ -886,9 +886,12 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       linkStreamCompleted: false,
       linksExpanded: false,
     }
-    for (const materialization of [previous, candidate]) {
-      if (!materialization) continue
-      for (const row of materialization.rowsByEntity.values()) {
+    for (const rows of [
+      previousSourceRows(this.state, candidate),
+      candidate.rowsByEntity.values(),
+    ]) {
+      for (const row of rows) {
+        replacement.owned.add(projectionEntityKey(row.assertion))
         if (row.assertion.kind === "object") {
           const ref = row.assertion.ref
           replacement.objects.set(objectRefKey(ref), { ref, sortKey: objectRefSortKey(ref) })
@@ -915,54 +918,54 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
       incident.has(objectRefKey(ref.source)) || incident.has(objectRefKey(ref.target))
 
     const adapter = getInMemoryObjectMaterializerAdapter(this.objects)
-    adapter.visitExactLinks(projectId, (row) => {
-      const ref = linkRef(row)
-      if (touchesIncident(ref)) addReplacementLink(replacement, ref, true)
-    })
-    for (const override of this.state.linkOverrides.values()) {
-      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 (incident.size > 0) {
+      adapter.visitExactLinks(projectId, (row) => {
+        const ref = linkRef(row)
+        if (touchesIncident(ref)) addReplacementLink(replacement, ref, true)
+      })
+      for (const override of this.state.linkOverrides.values()) {
+        if (override.projectId !== projectId) continue
+        if (touchesIncident(override.ref)) addReplacementLink(replacement, override.ref, true)
       }
-      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()) {
-        if (row.assertion.kind === "link" && touchesIncident(row.assertion.ref)) {
-          addReplacementLink(replacement, row.assertion.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)
       }
-    }
-
-    adapter.visitExactLinks(projectId, (row) => {
-      const ref = linkRef(row)
-      if (replacement.affectedScopes.has(linkScopeSortKey(ref.source, ref.linkId))) {
-        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
-        )
+      for (const [scopeKey, rows] of this.state.activeSourceLinkScopes) {
+        if (JSON.parse(scopeKey)[0] !== projectId) continue
+        for (const row of rows.values()) {
+          if (row.assertion.kind === "link" && touchesIncident(row.assertion.ref)) {
+            addReplacementLink(replacement, row.assertion.ref, true)
+          }
+        }
       }
     }
+    const scopes = new Map<string, { source: OntologyObjectRef; linkId: string }>()
+    for (const { ref } of replacement.links.values()) {
+      const key = linkScopeSortKey(ref.source, ref.linkId)
+      if (replacement.affectedScopes.has(key)) scopes.set(key, ref)
+    }
+    for (const scope of scopes.values()) {
+      adapter.visitExactScopeLinks(
+        projectId,
+        scope.source.objectTypeId,
+        scope.source.primaryId,
+        scope.linkId,
+        (row) => {
+          addReplacementLink(replacement, linkRef(row), false)
+        }
+      )
+      const override = this.state.linkSlotOverrides.get(
+        projectEntityKey(projectId, linkScopeKey(scope.source, scope.linkId))
+      )
+      if (override)
+        addReplacementLink(replacement, { ...scope, target: override.value.target }, false)
+    }
     replacement.linksExpanded = true
     replacement.orderedLinks = null
   }
@@ -1206,31 +1209,15 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     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)
+    const rows = this.state.activeSourceLinkScopes.get(
+      projectEntityKey(projectId, linkScopeSortKey(source, linkId))
+    )
+    if (rows && rows.size > 1)
+      throw new MaterializationConflictError(
+        "source-materialization",
+        `Multiple active source links assert cardinality-one scope '${source.objectTypeId}.${linkId}'.`
+      )
+    return structuredClone(rows?.values().next().value ?? null)
   }
 
   private findActiveObjectSource(
@@ -1250,19 +1237,13 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
   }
 
   private findActiveSource(projectId: string, entityKey: string): StoredSourceAssertion | null {
-    let found: StoredSourceAssertion | null = null
-    for (const active of this.state.sourceMaterializations.values()) {
-      if (active.projectId !== projectId || active.status !== "active") continue
-      const row = active.rowsByEntity.get(entityKey)
-      if (!row) continue
-      if (found)
-        throw new MaterializationConflictError(
-          "source-materialization",
-          `Multiple active sources assert ${entityKey}.`
-        )
-      found = storedSource(active.source.projectionId, active.materializationId, row)
-    }
-    return structuredClone(found)
+    const rows = this.state.activeSourceRows.get(projectEntityKey(projectId, entityKey))
+    if (rows && rows.size > 1)
+      throw new MaterializationConflictError(
+        "source-materialization",
+        `Multiple active sources assert ${entityKey}.`
+      )
+    return structuredClone(rows?.values().next().value ?? null)
   }
 
   private incidentLinkRefs(
@@ -1307,9 +1288,9 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
         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()) {
+    for (const [scopeKey, rows] of this.state.activeSourceLinkScopes) {
+      if (JSON.parse(scopeKey)[0] !== projectId) continue
+      for (const row of rows.values()) {
         if (row.assertion.kind === "link") consider(row.assertion.ref)
       }
     }

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

@@ -2,6 +2,7 @@ import { MaterializationValidationError } from "../../../materialization/errors"
 import type {
   LinkSlotOverride,
   OntologyMaterializationOrigin,
+  ProjectionEntityRef,
 } from "../../../materialization/model"
 import type { OntologyCommitOriginSelector, OntologyCommitRecord } from "../commits"
 import type {
@@ -11,9 +12,24 @@ import type {
   StoredObjectOverride,
 } from "../materializations"
 import type { OntologyOutboxRecord } from "../outbox"
-import type { OntologySourceRecord, StageSourceAssertion } from "../sources"
+import type {
+  OntologySourceRecord,
+  StageSourceAssertion,
+  StoredSourceAssertion,
+  StoredSourceLinkAssertion,
+} from "../sources"
+
+export interface InMemorySourceRoot {
+  readonly root: ProjectionEntityRef
+  readonly stagingOrdinal: number
+  readonly deleted: boolean
+  readonly entityKeys: Set<string>
+  active: boolean
+  retiredAt: string | null
+}
 
 export interface InMemorySourceMaterialization extends OntologySourceRecord {
+  readonly roots: Map<string, InMemorySourceRoot>
   readonly rowsByEntity: Map<string, StageSourceAssertion>
   readonly rootOrdinals: Map<string, number>
   readonly ordinalRoots: Map<number, string>
@@ -37,6 +53,10 @@ export interface InMemoryOntologyState {
   readonly commitIdByIdempotency: Map<string, string>
   readonly commitIdByOrigin: Map<string, string>
   readonly sourceMaterializations: Map<string, InMemorySourceMaterialization>
+  readonly activeSourceHeads: Map<string, string>
+  readonly activeSourceRoots: Map<string, Map<string, string>>
+  readonly activeSourceRows: Map<string, Map<string, StoredSourceAssertion>>
+  readonly activeSourceLinkScopes: Map<string, Map<string, StoredSourceLinkAssertion>>
   readonly objectOverrides: Map<string, InMemoryStoredObjectOverride>
   readonly linkOverrides: Map<string, InMemoryStoredLinkOverride>
   readonly linkSlotOverrides: Map<string, InMemoryStoredLinkSlotOverride>
@@ -57,6 +77,10 @@ export function createInMemoryOntologyState(): InMemoryOntologyState {
     commitIdByIdempotency: new Map(),
     commitIdByOrigin: new Map(),
     sourceMaterializations: new Map(),
+    activeSourceHeads: new Map(),
+    activeSourceRoots: new Map(),
+    activeSourceRows: new Map(),
+    activeSourceLinkScopes: new Map(),
     objectOverrides: new Map(),
     linkOverrides: new Map(),
     linkSlotOverrides: new Map(),
@@ -83,6 +107,7 @@ export function sourceMaterializationRecord(
     rowsByEntity: _rows,
     rootOrdinals: _roots,
     ordinalRoots: _ordinals,
+    roots: _sourceRoots,
     ...record
   } = materialization
   return structuredClone(record)

package/src/storage/ontology/in-memory/source-roots.ts

@@ -0,0 +1,123 @@
+import { MaterializationConflictError } from "../../../materialization/errors"
+import { linkScopeSortKey, projectionEntityKey } from "../../../materialization/refs"
+import type { SourceActivationWrite } from "../materializations"
+import type { StoredSourceAssertion, StoredSourceLinkAssertion } from "../sources"
+import { storedSource } from "./materializations-state"
+import {
+  type InMemoryOntologyState,
+  type InMemorySourceMaterialization,
+  projectEntityKey,
+  sourceMaterializationKey,
+} from "./shared-state"
+
+export function* previousSourceRows(
+  state: InMemoryOntologyState,
+  candidate: InMemorySourceMaterialization
+): Iterable<StoredSourceAssertion> {
+  const sourceKey = projectEntityKey(candidate.projectId, candidate.source.projectionId)
+  const active = state.activeSourceRoots.get(sourceKey)
+  if (!active) return
+  for (const rootKey of candidate.base ? candidate.roots.keys() : active.keys()) {
+    const materializationId = active.get(rootKey)
+    if (!materializationId) continue
+    const materialization = state.sourceMaterializations.get(
+      sourceMaterializationKey(
+        candidate.projectId,
+        candidate.source.projectionId,
+        materializationId
+      )
+    )!
+    for (const entityKey of materialization.roots.get(rootKey)!.entityKeys) {
+      yield storedSource(
+        candidate.source.projectionId,
+        materializationId,
+        materialization.rowsByEntity.get(entityKey)!
+      )
+    }
+  }
+}
+
+export function activateSourceRoots(
+  state: InMemoryOntologyState,
+  candidate: InMemorySourceMaterialization,
+  activation: SourceActivationWrite
+): void {
+  if (
+    candidate.base &&
+    (candidate.base.materializationId !== activation.expected.activeMaterializationId ||
+      candidate.base.lastCommitId !== activation.expected.lastCommitId)
+  ) {
+    throw new MaterializationConflictError(
+      "projection-fence",
+      "Source delta base changed before activation."
+    )
+  }
+  const sourceKey = projectEntityKey(candidate.projectId, candidate.source.projectionId)
+  const active = state.activeSourceRoots.get(sourceKey) ?? new Map<string, string>()
+  for (const key of candidate.base ? candidate.roots.keys() : [...active.keys()]) {
+    const materializationId = active.get(key)
+    if (!materializationId) continue
+    const old = state.sourceMaterializations.get(
+      sourceMaterializationKey(
+        candidate.projectId,
+        candidate.source.projectionId,
+        materializationId
+      )
+    )!
+    const root = old.roots.get(key)!
+    root.active = false
+    root.retiredAt = activation.updatedAt
+    active.delete(key)
+    for (const entityKey of root.entityKeys) {
+      const row = old.rowsByEntity.get(entityKey)!
+      const indexKey = projectEntityKey(candidate.projectId, entityKey)
+      const sources = state.activeSourceRows.get(indexKey)!
+      sources.delete(candidate.source.projectionId)
+      if (sources.size === 0) state.activeSourceRows.delete(indexKey)
+      if (row.assertion.kind === "link") {
+        const scopeKey = projectEntityKey(
+          candidate.projectId,
+          linkScopeSortKey(row.assertion.ref.source, row.assertion.ref.linkId)
+        )
+        const scope = state.activeSourceLinkScopes.get(scopeKey)!
+        scope.delete(JSON.stringify([candidate.source.projectionId, entityKey]))
+        if (scope.size === 0) state.activeSourceLinkScopes.delete(scopeKey)
+      }
+    }
+  }
+  for (const [rootKey, root] of candidate.roots) {
+    root.active = !root.deleted
+    root.retiredAt = root.deleted ? activation.updatedAt : null
+    if (root.deleted) continue
+    active.set(rootKey, candidate.materializationId)
+    for (const entityKey of root.entityKeys) {
+      // These are internal immutable assertions. Share their payload between indexes;
+      // read methods clone returned values and transaction snapshots preserve aliases.
+      const row = {
+        source: candidate.source,
+        materializationId: candidate.materializationId,
+        ...candidate.rowsByEntity.get(entityKey)!,
+      } as StoredSourceAssertion
+      const indexKey = projectEntityKey(candidate.projectId, projectionEntityKey(row.assertion))
+      const sources =
+        state.activeSourceRows.get(indexKey) ?? new Map<string, StoredSourceAssertion>()
+      sources.set(candidate.source.projectionId, row)
+      state.activeSourceRows.set(indexKey, sources)
+      if (row.assertion.kind === "link") {
+        const scopeKey = projectEntityKey(
+          candidate.projectId,
+          linkScopeSortKey(row.assertion.ref.source, row.assertion.ref.linkId)
+        )
+        const scope =
+          state.activeSourceLinkScopes.get(scopeKey) ?? new Map<string, StoredSourceLinkAssertion>()
+        scope.set(
+          JSON.stringify([candidate.source.projectionId, entityKey]),
+          row as StoredSourceLinkAssertion
+        )
+        state.activeSourceLinkScopes.set(scopeKey, scope)
+      }
+    }
+  }
+  state.activeSourceRoots.set(sourceKey, active)
+  state.activeSourceHeads.set(sourceKey, candidate.materializationId)
+}

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

@@ -13,6 +13,7 @@ import {
   isExactStagingManifest,
   sourceConflict,
   sourceMaterializationIdentity,
+  sourceStageRoots,
 } from "../provider"
 import type {
   AbandonSourceMaterializationCandidateInput,
@@ -32,6 +33,7 @@ import type {
   SummarizeTerminalSourceMaterializationsInput,
   TerminalSourceMaterializationSummary,
 } from "../sources"
+import { findActiveSourceMaterialization } from "./materializations-state"
 import {
   assertNonblank,
   type InMemoryOntologyState,
@@ -93,6 +95,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         projectionRevision: input.projectionRevision,
         ownershipHash: input.ownershipHash,
         ontologyRevision: input.ontologyRevision,
+        ...(input.base ? { base: structuredClone(input.base) } : {}),
         rootCount: null,
         assertionCount: null,
         createdAt: input.createdAt,
@@ -102,6 +105,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         lastCommitId: null,
         updatedAt: input.createdAt,
         rowsByEntity: new Map(),
+        roots: new Map(),
         rootOrdinals: new Map(),
         ordinalRoots: new Map(),
       }
@@ -121,7 +125,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
           `Source materialization '${input.materializationId}' is '${materialization.status}' and cannot accept rows.`
         )
       }
-      return stageRowsAtomically(materialization, input.rows)
+      return stageRowsAtomically(materialization, input)
     })
   }
 
@@ -178,18 +182,12 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
   async getActive(input: GetActiveOntologySourceInput): Promise<OntologySourceRecord | null> {
     return this.runRootOperation(() => {
       assertProjectAndSource(input)
-      const active = [...this.state.sourceMaterializations.values()].filter(
-        (materialization) =>
-          materialization.projectId === input.projectId &&
-          materialization.source.projectionId === input.source.projectionId &&
-          materialization.status === "active"
+      const active = findActiveSourceMaterialization(
+        this.state,
+        input.projectId,
+        input.source.projectionId
       )
-      if (active.length > 1) {
-        throw sourceConflict(
-          `Source '${input.source.projectionId}' has more than one active materialization.`
-        )
-      }
-      return active[0] ? sourceMaterializationRecord(active[0]) : null
+      return active ? sourceMaterializationRecord(active) : null
     })
   }
 
@@ -230,6 +228,14 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         ) {
           continue
         }
+        if (
+          materialization.roots.size > 0 &&
+          ![...materialization.roots.values()].some(
+            (root) =>
+              !root.active && root.retiredAt !== null && root.retiredAt < input.terminalBefore
+          )
+        )
+          continue
         insertBounded(candidates, entry, input.limit, compareTerminalMaterializations)
       }
 
@@ -240,18 +246,28 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         if (remaining === 0) break
         const current = this.state.sourceMaterializations.get(key)
         if (current !== candidate) continue
-        // Terminal manifests never participate in reads or activation again. Release their
-        // ingestion-only indexes immediately instead of retaining O(root count) memory until the
-        // last child row is removed by a later bounded cleanup pass.
         current.rootOrdinals.clear()
         current.ordinalRoots.clear()
-        for (const entityKey of current.rowsByEntity.keys()) {
+        for (const [rootKey, root] of current.roots) {
           if (remaining === 0) break
-          current.rowsByEntity.delete(entityKey)
-          rowsDeleted += 1
-          remaining -= 1
+          if (root.active || root.retiredAt === null || root.retiredAt >= input.terminalBefore)
+            continue
+          for (const entityKey of root.entityKeys) {
+            if (remaining === 0) break
+            current.rowsByEntity.delete(entityKey)
+            root.entityKeys.delete(entityKey)
+            rowsDeleted += 1
+            remaining -= 1
+          }
+          if (root.entityKeys.size === 0 && remaining > 0) {
+            current.roots.delete(rootKey)
+            current.rootOrdinals.delete(rootKey)
+            current.ordinalRoots.delete(root.stagingOrdinal)
+            rowsDeleted += 1
+            remaining -= 1
+          }
         }
-        if (current.rowsByEntity.size === 0 && remaining > 0) {
+        if (current.roots.size === 0 && current.rowsByEntity.size === 0 && remaining > 0) {
           this.state.sourceMaterializations.delete(key)
           materializationsDeleted += 1
           remaining -= 1
@@ -372,6 +388,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
     if (materialization.readyAt !== null) {
       assertNotBefore(abandonedAt, materialization.readyAt, "Source abandonedAt", "readyAt")
     }
+    for (const root of materialization.roots.values()) root.retiredAt = abandonedAt
     const abandoned: InMemorySourceMaterialization = {
       ...materialization,
       status: "abandoned",
@@ -407,14 +424,33 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
 
 function stageRowsAtomically(
   materialization: InMemorySourceMaterialization,
-  rows: StageSourceRowsInput["rows"]
+  input: StageSourceRowsInput
 ): StageSourceRowsResult {
   let inserted = 0
   let unchanged = 0
   const newRows = new Map<string, StageSourceRowsInput["rows"][number]>()
   const newRootOrdinals = new Map<string, number>()
   const newOrdinalRoots = new Map<number, string>()
-  for (const row of rows) {
+  const roots = sourceStageRoots(materialization.projectionKind, input)
+  if (!materialization.base && roots.some((root) => root.deleted)) {
+    throw new MaterializationValidationError("Root deletions require a source delta base.")
+  }
+  for (const root of roots) {
+    const previous = materialization.roots.get(root.rootKey)
+    const otherRoot = materialization.ordinalRoots.get(root.stagingOrdinal)
+    if (
+      (previous &&
+        (previous.deleted !== root.deleted || previous.stagingOrdinal !== root.stagingOrdinal)) ||
+      (otherRoot !== undefined && otherRoot !== root.rootKey)
+    ) {
+      throw new MaterializationValidationError(
+        "Source materialization repeats root or stream ordinal with different content."
+      )
+    }
+    newRootOrdinals.set(root.rootKey, root.stagingOrdinal)
+    newOrdinalRoots.set(root.stagingOrdinal, root.rootKey)
+  }
+  for (const row of input.rows) {
     assertSourceStagedRow(materialization.projectionKind, row)
 
     const rootKey = projectionEntityKey(row.root)
@@ -458,7 +494,21 @@ function stageRowsAtomically(
   for (const [ordinal, rootKey] of newOrdinalRoots) {
     materialization.ordinalRoots.set(ordinal, rootKey)
   }
-  for (const [entityKey, row] of newRows) materialization.rowsByEntity.set(entityKey, row)
+  for (const root of roots) {
+    if (!materialization.roots.has(root.rootKey))
+      materialization.roots.set(root.rootKey, {
+        root: structuredClone(root.root),
+        stagingOrdinal: root.stagingOrdinal,
+        deleted: root.deleted,
+        entityKeys: new Set(),
+        active: false,
+        retiredAt: null,
+      })
+  }
+  for (const [entityKey, row] of newRows) {
+    materialization.rowsByEntity.set(entityKey, row)
+    materialization.roots.get(projectionEntityKey(row.root))!.entityKeys.add(entityKey)
+  }
   return { inserted, unchanged }
 }
 
@@ -497,6 +547,11 @@ function assertReadyTopology(materialization: InMemorySourceMaterialization): vo
 
   for (const rootKey of materialization.rootOrdinals.keys()) {
     const rows = rowsByRoot.get(rootKey) ?? []
+    if (materialization.roots.get(rootKey)?.deleted) {
+      if (rows.length > 0)
+        throw new MaterializationValidationError("Deleted source roots cannot contain assertions.")
+      continue
+    }
     const first = rows[0]
     if (!first) {
       throw new MaterializationValidationError(`Source root ${rootKey} has no staged assertions.`)

package/src/storage/ontology/index.ts

@@ -109,6 +109,7 @@ export type {
   OntologySourceStorage,
   ReclaimSourceMaterializationInput,
   StageSourceAssertion,
+  StageSourceRoot,
   StageSourceRowsInput,
   StageSourceRowsResult,
   StoredSourceAssertion,