@sixb/core 0.1.9 → 0.1.11

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

@@ -31,6 +31,7 @@ export interface ConnectorConnectionPersistence {
   deleteAuthorizationAttempt(id: string): Promise<boolean>
 
   insertConnectionRun(record: ConnectorConnectionRunRecord): Promise<boolean>
+  listPendingConnectionRuns(): Promise<readonly ConnectorConnectionRunRecord[]>
   getConnectionRun(id: string): Promise<ConnectorConnectionRunRecord | null>
   updateConnectionRun(record: ConnectorConnectionRunRecord): Promise<void>
 
@@ -88,6 +89,7 @@ export async function currentConnectionRun(
   const run = await persistence.getConnectionRun(runId)
   if (!run || (run.status !== "waiting" && run.status !== "running")) return run
 
+  if (run.status === "waiting" && run.waitingFor === "account_selection") return run
   const now = await persistence.now()
   if (run.expiresAt.getTime() > now.getTime()) return run
 
@@ -96,9 +98,6 @@ export async function currentConnectionRun(
     if (attempt) await persistence.deleteAuthorizationAttempt(attempt.id)
   }
   if (run.status === "waiting") {
-    if (run.kind === "connect" && run.waitingFor === "account_selection") {
-      await markPendingAuthorizationForCleanup(persistence, run.authorizationId, now)
-    }
     const expired = expireConnectionRun(run, now)
     await persistence.updateConnectionRun(expired)
     return expired

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

@@ -77,6 +77,12 @@ export class DurableConnectorConnectionStorage implements ConnectorConnectionSto
     return this.runs.finishConnectionRun(...args)
   }
 
+  listPendingConnectionRuns(
+    ...args: Parameters<ConnectorConnectionStorage["listPendingConnectionRuns"]>
+  ) {
+    return this.runs.listPendingConnectionRuns(...args)
+  }
+
   async getConnectionRun(
     ...args: Parameters<ConnectorConnectionStorage["getConnectionRun"]>
   ): Promise<Awaited<ReturnType<ConnectorConnectionStorage["getConnectionRun"]>>> {

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

@@ -58,6 +58,7 @@ export interface ConnectorConnectionRunAwaitingSelectionRecord extends Connector
   readonly status: "waiting"
   readonly waitingFor: "account_selection"
   readonly authorizationId: string
+  /** Legacy persistence field; account selection no longer expires. */
   readonly expiresAt: Date
 }
 
@@ -198,7 +199,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 +221,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
@@ -278,7 +280,7 @@ export interface ConnectorAuthorizationRecord {
   readonly scopes: readonly string[]
   readonly accounts: readonly ConnectorAccountCandidate[]
   readonly status: ConnectorAuthorizationStatus
-  /** Storage-authoritative deadline for the first account selection. */
+  /** Legacy persistence field; no longer enforced as a selection deadline. */
   readonly selectionExpiresAt?: Date
   readonly revision: number
   readonly credentialMutation?: ConnectorCredentialMutation
@@ -477,6 +479,9 @@ export interface ConnectorConnectionStorage {
   finishConnectionRun(
     input: FinishConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null>
+  listPendingConnectionRuns(
+    input: ListConnectorConnectionsInput
+  ): Promise<readonly ConnectorConnectionRunRecord[]>
   getConnectionRun(
     input: GetConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null>

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)
@@ -151,9 +176,16 @@ export function insertBounded<T>(
   limit: number,
   compare: (left: T, right: T) => number
 ): void {
-  let index = values.findIndex((candidate) => compare(value, candidate) < 0)
-  if (index < 0) index = values.length
-  values.splice(index, 0, value)
+  if (limit <= 0) return
+  if (values.length >= limit && compare(value, values[values.length - 1]!) >= 0) return
+  let low = 0
+  let high = values.length
+  while (low < high) {
+    const middle = (low + high) >>> 1
+    if (compare(value, values[middle]!) < 0) high = middle
+    else low = middle + 1
+  }
+  values.splice(low, 0, value)
   if (values.length > limit) values.pop()
 }
 

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