@sixb/core 0.1.9 → 0.1.11

package/src/projections/run-dispatch.ts

@@ -1,7 +1,4 @@
 import { randomUUID } from "node:crypto"
-import { reportRunFailure } from "../error-reporting/capability"
-import { createSixbError, toSixbFailure } from "../errors/internal"
-import type { SixbFailure } from "../errors/types"
 import type { RunDispatcher } from "../execution/dispatch"
 import { createPrimitiveExecutionRecord } from "../execution/durable"
 import type { DatasetProducer, LakeStorage } from "../lake-storage"
@@ -17,11 +14,7 @@ import {
 import { getProjectionRegistry } from "./capability"
 import { ProjectionValidationError } from "./errors"
 import { createProjectionRunId } from "./run-id"
-import {
-  PROJECTION_RUN_FAILURE_CODES,
-  type ProjectionDefinition,
-  type ProjectionRunFailureCode,
-} from "./types"
+import type { ProjectionDefinition } from "./types"
 
 /** Target maximum mapped points per telemetry commit; a single-property projection reads 500 rows. */
 export const PROJECTION_TELEMETRY_BATCH_SIZE = 500
@@ -106,7 +99,7 @@ export class ProjectionRunDispatcher implements ProjectionRunDispatchPort {
     const runId = createProjectionRunId(this.dependencies.id, identity)
     const projectionRuns = requireProjectionRunStorage(this.dependencies.storage)
     const existing = await projectionRuns.getById({ projectId: this.dependencies.id, id: runId })
-    const persisted = existing
+    let persisted = existing
       ? await reuseProjectionRun(this.dependencies, existing, identity)
       : await persistProjectionRun({
           dependencies: this.dependencies,
@@ -120,6 +113,9 @@ export class ProjectionRunDispatcher implements ProjectionRunDispatchPort {
           ),
         })
 
+    if (!persisted.publish && persisted.run.status === "queued") {
+      persisted = await reuseProjectionRun(this.dependencies, persisted.run, identity)
+    }
     if (!persisted.publish) return existingResult(persisted.run)
     return publishProjectionRun(this.dependencies, input.metadata, persisted)
   }
@@ -195,6 +191,9 @@ async function reuseProjectionRun(
   identity: ProjectionRunRecord["identity"]
 ): Promise<PersistedProjectionRun> {
   await assertExistingRun(dependencies.storage, existing, identity)
+  if (existing.status === "queued") {
+    return { publish: true, run: existing, queuedAt: existing.queuedAt, created: false }
+  }
   if (
     existing.status !== "failed" ||
     existing.error?.code !== "queue.enqueue_failed" ||
@@ -228,45 +227,29 @@ async function publishProjectionRun(
   metadata: Readonly<Record<string, string>> | undefined,
   persisted: Extract<PersistedProjectionRun, { readonly publish: true }>
 ): Promise<ProjectionRunDispatchResult> {
-  try {
-    const [job] = await dependencies.queues.projections.enqueue({
-      projectId: dependencies.id,
-      jobs: [
-        {
-          id: persisted.run.id,
-          type: "projection.run.requested",
-          payload: { runId: persisted.run.id },
-          ...(metadata === undefined ? {} : { metadata }),
-        },
-      ],
-    })
-    return {
-      projectionId: persisted.run.identity.projectionId,
-      runId: persisted.run.id,
-      queuedAt: persisted.queuedAt.toISOString(),
-      ...(job?.id ? { jobId: job.id } : {}),
-      created: persisted.created,
-    }
-  } catch (error) {
-    const failedAt = new Date()
-    const failure = toEnqueueFailure(error, persisted.run, failedAt)
-    const failed = await requireProjectionRunStorage(dependencies.storage).failEnqueue({
-      projectId: dependencies.id,
-      id: persisted.run.id,
-      finishedAt: failedAt,
-      error: failure,
-    })
-    reportRunFailure(dependencies, error, {
-      projectId: dependencies.id,
-      runKind: "projection",
-      run: {
-        runId: failed.id,
-        projectionId: failed.identity.projectionId,
-        projectionKind: failed.identity.projectionKind,
+  // Keep the run queued on uncertain publication; the caller retries the same identity.
+  const [job] = await dependencies.queues.projections.enqueue({
+    projectId: dependencies.id,
+    jobs: [
+      {
+        id: persisted.run.id,
+        type: "projection.run.requested",
+        payload: { runId: persisted.run.id },
+        ...(metadata === undefined ? {} : { metadata }),
       },
-      failure,
-    })
-    throw error
+    ],
+  })
+  if (!job || job.id !== persisted.run.id) {
+    throw new ProjectionRunError(
+      `[Sixb] Queue did not acknowledge Projection run '${persisted.run.id}'.`
+    )
+  }
+  return {
+    projectionId: persisted.run.identity.projectionId,
+    runId: persisted.run.id,
+    queuedAt: persisted.queuedAt.toISOString(),
+    ...(job?.id ? { jobId: job.id } : {}),
+    created: persisted.created,
   }
 }
 
@@ -478,24 +461,3 @@ function assertDispatchInput(input: ProjectionRunDispatchInput): void {
     throw new ProjectionValidationError("[Sixb] Projection dataset version timestamp is invalid.")
   }
 }
-
-function toEnqueueFailure(
-  error: unknown,
-  run: ProjectionRunRecord,
-  at: Date
-): SixbFailure<ProjectionRunFailureCode> {
-  const enqueueError = createSixbError(
-    "queue.enqueue_failed",
-    `[Sixb] Could not enqueue Projection run '${run.id}'.`,
-    {
-      cause: error,
-      details: {
-        projectionId: run.identity.projectionId,
-        projectionKind: run.identity.projectionKind,
-        runId: run.id,
-        phase: "enqueue",
-      },
-    }
-  )
-  return toSixbFailure(enqueueError, { allowedCodes: PROJECTION_RUN_FAILURE_CODES, at })
-}

package/src/queues/in-memory.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto"
 import type { SixbErrorCode } from "../errors/types"
 import { QueueError } from "./errors"
+import { IndexedHeap } from "./indexed-heap"
 import type {
   ActionQueueJobFailureCode,
   ActionRunRequestedQueueJob,
@@ -29,6 +30,9 @@ interface QueueRecord<TQueueJob extends QueueJob = QueueJob> {
   readonly sequence: number
   readonly queueId: string
   job: TQueueJob
+  availableAtMs: number
+  readonly createdAtMs: number
+  leaseExpiryMs: number | null
   // A leased job stays "queued" until a worker completes or fails it.
   state: QueueRecordState
   failure: QueueJobFailure | null
@@ -63,25 +67,15 @@ function clearLease(record: QueueRecord): void {
   record.leaseId = null
   record.claimedAt = null
   record.leaseExpiresAt = null
+  record.leaseExpiryMs = null
 }
 
 // Best-effort ordering is part of the contract; this keeps the in-memory provider deterministic.
 function compareQueueRecords(left: QueueRecord, right: QueueRecord): number {
-  const availableDifference =
-    parseTimestamp(left.job.availableAt, "job.availableAt") -
-    parseTimestamp(right.job.availableAt, "job.availableAt")
-
-  if (availableDifference !== 0) {
-    return availableDifference
-  }
-
-  const createdDifference =
-    parseTimestamp(left.job.createdAt, "job.createdAt") -
-    parseTimestamp(right.job.createdAt, "job.createdAt")
-
-  if (createdDifference !== 0) {
-    return createdDifference
-  }
+  const availableDifference = left.availableAtMs - right.availableAtMs
+  if (availableDifference !== 0) return availableDifference
+  const createdDifference = left.createdAtMs - right.createdAtMs
+  if (createdDifference !== 0) return createdDifference
 
   return left.sequence - right.sequence
 }
@@ -107,11 +101,18 @@ function createQueueJob<TQueueJob extends QueueJob>(
 }
 
 function leaseExpiresAtMs(record: QueueRecord): number | null {
-  if (!record.leaseId || !record.leaseExpiresAt) {
-    return null
-  }
+  return record.leaseExpiryMs
+}
 
-  return parseTimestamp(record.leaseExpiresAt, "leaseExpiresAt")
+function eligibleAt(record: QueueRecord): number {
+  return Math.max(record.availableAtMs, record.leaseExpiryMs ?? -Infinity)
+}
+
+interface QueueLane {
+  // Terminal records remain here for caller-id deduplication, never in the delivery indexes.
+  readonly records: Map<string, QueueRecord>
+  readonly ready: IndexedHeap<QueueRecord>
+  readonly waiting: IndexedHeap<QueueRecord>
 }
 
 function toClaimedQueueJob<TQueueJob extends QueueJob>(
@@ -130,27 +131,26 @@ function toClaimedQueueJob<TQueueJob extends QueueJob>(
 }
 
 class InMemoryQueueStore {
-  private readonly recordsByProject = new Map<string, QueueRecord[]>()
+  private readonly projects = new Map<string, Map<string, QueueLane>>()
   private nextSequence = 1
 
   add<TQueueJob extends QueueJob>(projectId: string, queueId: string, job: TQueueJob): void {
-    const records = this.getOrCreateRecords(projectId)
-    records.push({
-      sequence: this.nextSequence,
+    const lane = this.lane(projectId, queueId)
+    const record: QueueRecord = {
+      sequence: this.nextSequence++,
       queueId,
       job,
+      availableAtMs: parseTimestamp(job.availableAt, "job.availableAt"),
+      createdAtMs: parseTimestamp(job.createdAt, "job.createdAt"),
+      leaseExpiryMs: null,
       state: "queued",
       failure: null,
       leaseId: null,
       claimedAt: null,
       leaseExpiresAt: null,
-    })
-    this.nextSequence += 1
-  }
-
-  list<TQueueJob extends QueueJob>(projectId: string, queueId: string): QueueRecord<TQueueJob>[] {
-    const records = this.recordsByProject.get(projectId) ?? []
-    return records.filter((record) => record.queueId === queueId) as QueueRecord<TQueueJob>[]
+    }
+    lane.records.set(job.id, record)
+    this.schedule(projectId, record, Date.now())
   }
 
   find<TQueueJob extends QueueJob>(
@@ -158,20 +158,67 @@ class InMemoryQueueStore {
     queueId: string,
     jobId: string
   ): QueueRecord<TQueueJob> | null {
-    return (
-      this.list<TQueueJob>(projectId, queueId).find((record) => record.job.id === jobId) ?? null
-    )
+    return (this.projects.get(projectId)?.get(queueId)?.records.get(jobId) ??
+      null) as QueueRecord<TQueueJob> | null
   }
 
-  private getOrCreateRecords(projectId: string): QueueRecord[] {
-    const existing = this.recordsByProject.get(projectId)
-    if (existing) {
-      return existing
+  schedule(projectId: string, record: QueueRecord, now: number): void {
+    const lane = this.lane(projectId, record.queueId)
+    if (record.state !== "queued") {
+      lane.ready.delete(record)
+      lane.waiting.delete(record)
+    } else if (eligibleAt(record) <= now) {
+      lane.waiting.delete(record)
+      lane.ready.set(record)
+    } else {
+      lane.ready.delete(record)
+      lane.waiting.set(record)
+    }
+  }
+
+  takeReady<TQueueJob extends QueueJob>(
+    projectId: string,
+    queueId: string,
+    now: number,
+    limit: number
+  ): QueueRecord<TQueueJob>[] {
+    const lane = this.projects.get(projectId)?.get(queueId)
+    if (!lane) return []
+    // Wake delayed jobs and expired leases, then order all ready jobs by the original contract.
+    // A lease expiry controls eligibility, not the priority of a redelivered job.
+    while (lane.waiting.peek() && eligibleAt(lane.waiting.peek()!) <= now) {
+      lane.ready.set(lane.waiting.pop()!)
     }
+    const selected: QueueRecord[] = []
+    while (selected.length < limit) {
+      const record = lane.ready.peek()
+      if (!record || record.availableAtMs > now) break
+      lane.ready.pop()
+      // A backwards wall-clock adjustment can make a previously expired lease live again.
+      if (eligibleAt(record) > now) lane.waiting.set(record)
+      else selected.push(record)
+    }
+    return selected as QueueRecord<TQueueJob>[]
+  }
 
-    const records: QueueRecord[] = []
-    this.recordsByProject.set(projectId, records)
-    return records
+  private lane(projectId: string, queueId: string): QueueLane {
+    let queues = this.projects.get(projectId)
+    if (!queues) {
+      queues = new Map()
+      this.projects.set(projectId, queues)
+    }
+    let lane = queues.get(queueId)
+    if (!lane) {
+      lane = {
+        records: new Map(),
+        ready: new IndexedHeap(compareQueueRecords),
+        waiting: new IndexedHeap(
+          (left, right) => eligibleAt(left) - eligibleAt(right) || left.sequence - right.sequence
+        ),
+      }
+      queues.set(queueId, lane)
+    }
+    return lane
   }
 }
 
@@ -219,8 +266,8 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     assertNonEmpty(params.projectId, "projectId")
     assertNonEmpty(params.workerId, "workerId")
 
-    const limit = params.limit ?? 1
-    if (limit <= 0) {
+    const limit = Math.trunc(params.limit ?? 1)
+    if (!(limit > 0)) {
       return []
     }
 
@@ -228,24 +275,11 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     assertPositiveNumber(leaseMs, "leaseMs")
 
     const now = Date.now()
-    const claimable = this.store
-      .list<TQueueJob>(params.projectId, this.queueId)
-      .filter((record) => {
-        if (record.state !== "queued") {
-          return false
-        }
-
-        if (parseTimestamp(record.job.availableAt, "job.availableAt") > now) {
-          return false
-        }
-
-        const expiresAt = leaseExpiresAtMs(record)
-        return expiresAt === null || expiresAt <= now
-      })
-      .sort(compareQueueRecords)
-      .slice(0, limit)
-
     const claimedAt = new Date(now).toISOString()
+    // Validate before removing candidates, and cache the same millisecond precision we return.
+    const leaseExpiry = new Date(now + leaseMs)
+    const leaseExpiresAt = leaseExpiry.toISOString()
+    const claimable = this.store.takeReady<TQueueJob>(params.projectId, this.queueId, now, limit)
 
     return claimable.map((record) => {
       // Attempts count claims so redelivery after lease expiry or retry is visible to workers.
@@ -255,7 +289,9 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
       }
       record.leaseId = randomUUID()
       record.claimedAt = claimedAt
-      record.leaseExpiresAt = new Date(now + leaseMs).toISOString()
+      record.leaseExpiresAt = leaseExpiresAt
+      record.leaseExpiryMs = leaseExpiry.getTime()
+      this.store.schedule(params.projectId, record, now)
 
       return toClaimedQueueJob(record)
     })
@@ -265,6 +301,7 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     const record = this.requireActiveLease(params)
     record.state = "completed"
     clearLease(record)
+    this.store.schedule(params.projectId, record, Date.now())
   }
 
   async retry(params: {
@@ -275,13 +312,15 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
   }): Promise<void> {
     const record = this.requireActiveLease(params)
     const availableAt = params.availableAt ?? new Date().toISOString()
-    parseTimestamp(availableAt, "availableAt")
+    const availableAtMs = parseTimestamp(availableAt, "availableAt")
 
+    record.availableAtMs = availableAtMs
     record.job = {
       ...record.job,
       availableAt,
     }
     clearLease(record)
+    this.store.schedule(params.projectId, record, Date.now())
   }
 
   async fail(params: {
@@ -294,6 +333,7 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     record.state = "failed"
     record.failure = structuredClone(params.failure)
     clearLease(record)
+    this.store.schedule(params.projectId, record, Date.now())
   }
 
   async renewLease(params: {
@@ -319,7 +359,10 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
       return null
     }
 
-    record.leaseExpiresAt = new Date(now + params.leaseMs).toISOString()
+    const leaseExpiry = new Date(now + params.leaseMs)
+    record.leaseExpiresAt = leaseExpiry.toISOString()
+    record.leaseExpiryMs = leaseExpiry.getTime()
+    this.store.schedule(params.projectId, record, now)
     return toClaimedQueueJob(record)
   }
 

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 }),
@@ -411,6 +413,20 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     return structuredClone(finished)
   }
 
+  async listPendingConnectionRuns(
+    input: Parameters<ConnectorConnectionStorage["listPendingConnectionRuns"]>[0]
+  ): Promise<readonly ConnectorConnectionRunRecord[]> {
+    return [...this.connectionRuns.values()]
+      .filter(
+        (run) =>
+          run.projectId === input.projectId &&
+          run.connectorId === input.connectorId &&
+          (run.status === "running" ||
+            (run.status === "waiting" && run.waitingFor === "account_selection"))
+      )
+      .map((run) => structuredClone(run))
+  }
+
   async getConnectionRun(
     input: GetConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null> {
@@ -853,7 +869,7 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     input: PutConnectorConnectionInput,
     now: Date
   ): PutConnectorConnectionResult {
-    let authorization = this.authorizations.get(input.authorizationId)
+    const authorization = this.authorizations.get(input.authorizationId)
     if (
       !sameAuthorizationScope(authorization, input) ||
       !isSelectable(authorization.status) ||
@@ -861,20 +877,6 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     ) {
       throw authorizationConflict()
     }
-    if (
-      authorization.status === "pending_selection" &&
-      authorization.selectionExpiresAt!.getTime() <= now.getTime()
-    ) {
-      authorization = {
-        ...authorization,
-        status: "revocation_pending",
-        selectionExpiresAt: undefined,
-        revision: authorization.revision + 1,
-        updatedAt: now,
-      }
-      this.authorizations.set(authorization.id, authorization)
-      throw authorizationConflict()
-    }
     const account = authorization.accounts.find((candidate) => candidate.id === input.account.id)
     if (!account) {
       throw new ConnectorConnectionStorageError(
@@ -1076,6 +1078,7 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     const run = this.connectionRuns.get(runId)
     if (!run || (run.status !== "waiting" && run.status !== "running")) return run
 
+    if (run.status === "waiting" && run.waitingFor === "account_selection") return run
     const now = this.now()
     if (run.expiresAt.getTime() > now.getTime()) return run
 
@@ -1084,9 +1087,6 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
       if (attempt) this.attempts.delete(attempt.id)
     }
     if (run.status === "waiting") {
-      if (run.kind === "connect" && run.waitingFor === "account_selection") {
-        this.markPendingAuthorizationForCleanup(run.connectorId, run.authorizationId, now)
-      }
       const expired = expireConnectionRun(run, now)
       this.connectionRuns.set(run.id, expired)
       return expired

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

@@ -165,7 +165,7 @@ export class DurableConnectorConnections extends ConnectorConnectionOperations {
     input: PutConnectorConnectionInput,
     now: Date
   ): Promise<PutConnectorConnectionResult | CommittedConnectorConnectionError> {
-    let authorization = await persistence.getAuthorization(input.authorizationId)
+    const authorization = await persistence.getAuthorization(input.authorizationId)
     if (
       !authorization ||
       !isSelectable(authorization.status) ||
@@ -173,20 +173,6 @@ export class DurableConnectorConnections extends ConnectorConnectionOperations {
     ) {
       throw authorizationConflict()
     }
-    if (
-      authorization.status === "pending_selection" &&
-      authorization.selectionExpiresAt!.getTime() <= now.getTime()
-    ) {
-      authorization = {
-        ...authorization,
-        status: "revocation_pending",
-        selectionExpiresAt: undefined,
-        revision: authorization.revision + 1,
-        updatedAt: now,
-      }
-      await persistence.updateAuthorization(authorization)
-      return { error: authorizationConflict() }
-    }
     const account = authorization.accounts.find((candidate) => candidate.id === input.account.id)
     if (!account) {
       throw new ConnectorConnectionStorageError(

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 }),
@@ -358,6 +360,12 @@ export class DurableConnectorConnectionRuns extends ConnectorConnectionOperation
     })
   }
 
+  listPendingConnectionRuns(
+    input: Parameters<ConnectorConnectionStorage["listPendingConnectionRuns"]>[0]
+  ) {
+    return this.read(input, (persistence) => persistence.listPendingConnectionRuns())
+  }
+
   getConnectionRun(
     input: GetConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null> {