@sixb/core 0.1.9 → 0.1.10

package/src/queues/indexed-heap.ts

@@ -0,0 +1,74 @@
+/** Internal mutable priority index. Updating or removing an entry never leaves stale copies. */
+export class IndexedHeap<T> {
+  private readonly items: T[] = []
+  private readonly positions = new Map<T, number>()
+
+  constructor(private readonly compare: (left: T, right: T) => number) {}
+
+  peek(): T | undefined {
+    return this.items[0]
+  }
+
+  pop(): T | undefined {
+    const first = this.peek()
+    if (first !== undefined) this.delete(first)
+    return first
+  }
+
+  set(item: T): void {
+    const index = this.positions.get(item)
+    if (index === undefined) {
+      this.positions.set(item, this.items.length)
+      this.items.push(item)
+      this.up(this.items.length - 1)
+    } else {
+      this.down(this.up(index))
+    }
+  }
+
+  delete(item: T): void {
+    const index = this.positions.get(item)
+    if (index === undefined) return
+    const last = this.items.pop()!
+    this.positions.delete(item)
+    if (index === this.items.length) return
+    this.items[index] = last
+    this.positions.set(last, index)
+    this.down(this.up(index))
+  }
+
+  private up(start: number): number {
+    let index = start
+    while (index > 0) {
+      const parent = Math.floor((index - 1) / 2)
+      if (this.compare(this.items[parent]!, this.items[index]!) <= 0) break
+      this.swap(parent, index)
+      index = parent
+    }
+    return index
+  }
+
+  private down(start: number): void {
+    let index = start
+    while (index * 2 + 1 < this.items.length) {
+      const left = index * 2 + 1
+      const right = left + 1
+      const child =
+        right < this.items.length && this.compare(this.items[right]!, this.items[left]!) < 0
+          ? right
+          : left
+      if (this.compare(this.items[index]!, this.items[child]!) <= 0) break
+      this.swap(index, child)
+      index = child
+    }
+  }
+
+  private swap(left: number, right: number): void {
+    const a = this.items[left]!
+    const b = this.items[right]!
+    this.items[left] = b
+    this.items[right] = a
+    this.positions.set(a, right)
+    this.positions.set(b, left)
+  }
+}

package/src/runtime/host.ts

@@ -19,7 +19,6 @@ import type { BlobStorage } from "../blob-storage"
 import type { Broker } from "../broker"
 import { registerConnectorConnectionCallbackProcess } from "../connectors/connections/capability"
 import { createConnectorCredentialProtectorFromKey } from "../connectors/credentials"
-import { createConnectorCodedError } from "../connectors/errors"
 import { ConnectorService } from "../connectors/service"
 import {
   type ConnectorConnectionOptions,
@@ -185,7 +184,6 @@ export class SixbHost<
     })
     validateAuthStrategySecurityReferences(this.auth.getStrategy(), definitions.security)
     const connectors = definitions.connectors.list()
-    assertConnectorConnectionSurfaces(connectors)
     const hasOAuthConnectors = connectors.some(isOAuthConnectorDefinition)
     const credentialProtector =
       hasOAuthConnectors && options.connectorConnections?.encryptionKey !== undefined
@@ -386,15 +384,3 @@ function assertWebhookRunStorage(
     }
   }
 }
-
-function assertConnectorConnectionSurfaces(connectors: readonly ConnectorDefinition[]): void {
-  for (const connector of connectors) {
-    if (!isOAuthConnectorDefinition(connector)) continue
-    if (connector.adapter.webhooks !== undefined) {
-      throw createConnectorCodedError(
-        "connector.configuration_invalid",
-        `OAuth connector '${connector.id}' cannot register webhooks until connection routing is defined.`
-      )
-    }
-  }
-}

package/src/runtime/ontology-mutations.ts

@@ -3,13 +3,16 @@ import type {
   OntologyEditCommit,
   ProjectionCommitResult,
   ProjectionRunFinishInput,
+  ProjectionSourceRef,
   ProjectionSourceReplacement,
   TelemetryAppend,
   TelemetryCommitResult,
 } from "../materialization/model"
 import type { BoundOntologyMaterializer } from "../materializer"
+import type { OntologySourceRecord } from "../storage/ontology"
 
 export interface OntologyMutationRuntime {
+  getProjectionSource?(source: ProjectionSourceRef): Promise<OntologySourceRecord | null>
   commitEdits(input: OntologyEditCommit): Promise<EditCommitResult>
   replaceProjection(input: ProjectionSourceReplacement): Promise<ProjectionCommitResult>
   finishProjection(input: ProjectionRunFinishInput): Promise<void>
@@ -55,6 +58,7 @@ export function createOntologyMutationRuntime(input: {
   readonly notifyCommittedFacts: () => void
 }): OntologyMutationRuntime {
   const runtime: OntologyMutationRuntime = {
+    getProjectionSource: (source) => input.materializer.projections.getActive(source),
     commitEdits: (command) =>
       commitAndNotify(() => input.materializer.edits.commit(command), input.notifyCommittedFacts),
     replaceProjection: (command) =>

package/src/storage/connector-connections/in-memory.ts

@@ -147,7 +147,9 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
       slot: input.slot,
       initiatedByExecutionId: input.initiatedByExecutionId,
       stateHash: input.stateHash,
-      codeVerifier: structuredClone(input.codeVerifier),
+      ...(input.codeVerifier === undefined
+        ? {}
+        : { codeVerifier: structuredClone(input.codeVerifier) }),
       redirectUri: input.redirectUri,
       ...(input.connectionRunId === undefined ? {} : { connectionRunId: input.connectionRunId }),
       ...(input.returnTo === undefined ? {} : { returnTo: input.returnTo }),

package/src/storage/connector-connections/provider/runs.ts

@@ -63,7 +63,9 @@ export class DurableConnectorConnectionRuns extends ConnectorConnectionOperation
         slot: input.slot,
         initiatedByExecutionId: input.initiatedByExecutionId,
         stateHash: input.stateHash,
-        codeVerifier: structuredClone(input.codeVerifier),
+        ...(input.codeVerifier === undefined
+          ? {}
+          : { codeVerifier: structuredClone(input.codeVerifier) }),
         redirectUri: input.redirectUri,
         ...(input.connectionRunId === undefined ? {} : { connectionRunId: input.connectionRunId }),
         ...(input.returnTo === undefined ? {} : { returnTo: input.returnTo }),

package/src/storage/connector-connections/types.ts

@@ -198,7 +198,8 @@ export interface ConnectorAuthorizationAttemptRecord extends ConnectorConnection
   /** Durable execution that initiated and authorizes completion of this OAuth attempt. */
   readonly initiatedByExecutionId: string
   readonly stateHash: string
-  readonly codeVerifier: SealedConnectorCredential
+  /** Absent when the authorization attempt explicitly disabled PKCE. */
+  readonly codeVerifier?: SealedConnectorCredential
   readonly redirectUri: string
   /** Present only for attempts created by the headless connection-run API. */
   readonly connectionRunId?: string
@@ -219,7 +220,7 @@ export interface CreateConnectorAuthorizationAttemptInput extends ConnectorConne
   readonly connectorId: string
   readonly initiatedByExecutionId: string
   readonly stateHash: string
-  readonly codeVerifier: SealedConnectorCredential
+  readonly codeVerifier?: SealedConnectorCredential
   readonly redirectUri: string
   readonly connectionRunId?: string
   readonly returnTo?: string

package/src/storage/index.ts

@@ -532,6 +532,7 @@ export type {
   SourceReplacementStatePage,
   StageMaterializationWorkInput,
   StageSourceAssertion,
+  StageSourceRoot,
   StageSourceRowsInput,
   StageSourceRowsResult,
   StoredLinkOverride,

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

@@ -27,6 +27,7 @@ import type {
   InMemoryStoredLinkSlotOverride,
   InMemoryStoredObjectOverride,
 } from "./shared-state"
+import { projectEntityKey, sourceMaterializationKey } from "./shared-state"
 
 export function publicObjectOverride(
   value: InMemoryStoredObjectOverride | undefined
@@ -120,24 +121,10 @@ export function findActiveSourceMaterialization(
   projectId: string,
   sourceId: string
 ): InMemorySourceMaterialization | undefined {
-  let active: InMemorySourceMaterialization | undefined
-  for (const materialization of state.sourceMaterializations.values()) {
-    if (
-      materialization.projectId !== projectId ||
-      materialization.source.projectionId !== sourceId ||
-      materialization.status !== "active"
-    ) {
-      continue
-    }
-    if (active) {
-      throw new MaterializationConflictError(
-        "source-materialization",
-        `Source '${sourceId}' has more than one active materialization.`
-      )
-    }
-    active = materialization
-  }
-  return active
+  const id = state.activeSourceHeads.get(projectEntityKey(projectId, sourceId))
+  return id
+    ? state.sourceMaterializations.get(sourceMaterializationKey(projectId, sourceId, id))
+    : undefined
 }
 
 export function storedSource(

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)
+}