@sixb/core 0.1.1 → 0.1.3

package/src/storage/projection-runs/in-memory.ts

@@ -1,19 +1,28 @@
 import { randomUUID } from "node:crypto"
+import type { ExecutionStorage } from "../executions"
 import type { AssertSourceMaterializationExecutionInput } from "../ontology/sources"
-import { latestStartedAtByOwnerId } from "../run-listing"
+import {
+  compareStartedAt,
+  latestStartedAtByOwnerId,
+  matchesRunListDateFilters,
+} from "../run-listing"
 import { ProjectionRunError } from "./errors"
 import {
   advanceProjectionTelemetry,
   assertGenericProgressDoesNotAdvanceTelemetry,
   assertProjectionMissingTarget,
-  assertProjectionRunExecution,
+  assertProjectionRunAttempt,
+  assertProjectionRunDurableExecution,
   assertProjectionRunIdentityMatches,
   assertProjectionRunListWindow,
   assertProjectionRunNonEmpty,
+  assertProjectionRunQueueInput,
   assertProjectionRunRunning,
   assertProjectionRunStartInput,
+  canRequeueProjectionRunAfterEnqueueFailure,
   createProjectionRunClaim,
   createProjectionRunRecord,
+  failProjectionRunEnqueue,
   finishProjectionRunRecord,
   immutableDatasetVersionConflict,
   mergeProjectionRunProgress,
@@ -23,9 +32,10 @@ import {
   requireTelemetryProjectionRun,
   type StoredProjectionRunRecord,
   staleProjectionRunExecution,
-} from "./lifecycle"
+} from "./provider"
 import {
   type AdvanceProjectionTelemetryCheckpointInput,
+  type FailProjectionRunEnqueueInput,
   type FinishProjectionRunInput,
   type ListLatestProjectionRunsInput,
   type ListLatestProjectionRunsResult,
@@ -36,6 +46,7 @@ import {
   type ProjectionRunRecord,
   type ProjectionRunStorage,
   projectionRunObjectTypesVisible,
+  type QueueProjectionRunInput,
   type RecordProjectionMissingTargetInput,
   type StartOrReclaimProjectionRunInput,
   type TelemetryProjectionRunRecord,
@@ -50,10 +61,7 @@ function projectionRunKey(projectId: string, id: string): string {
 }
 
 function compareRuns(a: ProjectionRunRecord, b: ProjectionRunRecord, order: "asc" | "desc") {
-  const delta = a.startedAt.getTime() - b.startedAt.getTime()
-  if (delta !== 0) return order === "asc" ? delta : -delta
-  if (a.id === b.id) return 0
-  return order === "asc" ? a.id.localeCompare(b.id) : b.id.localeCompare(a.id)
+  return compareStartedAt(a, b, order)
 }
 
 export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
@@ -63,16 +71,18 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
   private readonly runRootOperation: RunRootOperation
   private readonly createExecutionToken: () => string
 
-  constructor(
-    input: {
-      readonly runRootOperation?: RunRootOperation
-      readonly executionToken?: () => string
-    } = {}
-  ) {
+  constructor(input: {
+    readonly executions: ExecutionStorage
+    readonly runRootOperation?: RunRootOperation
+    readonly executionToken?: () => string
+  }) {
+    this.executions = input.executions
     this.runRootOperation = input.runRootOperation ?? runDirectly
     this.createExecutionToken = input.executionToken ?? randomUUID
   }
 
+  private readonly executions: ExecutionStorage
+
   snapshot(): InMemoryProjectionRunStorageSnapshot {
     return structuredClone({
       rows: this.rows,
@@ -89,24 +99,78 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
     }
   }
 
+  async queue(input: QueueProjectionRunInput): Promise<ProjectionRunRecord> {
+    return this.runRootOperation(async () => {
+      assertProjectionRunQueueInput(input)
+      this.assertDatasetVersionIsImmutable(input)
+      const key = projectionRunKey(input.projectId, input.id)
+      const existing = this.rows.get(key)
+      if (existing && !canRequeueProjectionRunAfterEnqueueFailure(existing, input)) {
+        throw new ProjectionRunError(
+          `[Sixb] Projection run '${input.id}' already exists for project '${input.projectId}'.`
+        )
+      }
+      if (
+        [...this.rows.values()].some(
+          (run) =>
+            run.projectId === input.projectId &&
+            run.id !== input.id &&
+            run.executionId === input.executionId
+        )
+      ) {
+        throw new ProjectionRunError(
+          `[Sixb] Execution '${input.executionId}' already belongs to another Projection run.`
+        )
+      }
+      await assertProjectionRunDurableExecution({
+        executions: this.executions,
+        projectId: input.projectId,
+        executionId: input.executionId,
+        runId: input.id,
+        projectionId: input.identity.projectionId,
+        datasetId: input.identity.datasetVersion.datasetId,
+        datasetVersionId: input.identity.datasetVersion.versionId,
+      })
+      const record = createProjectionRunRecord(input)
+      this.rows.set(key, structuredClone(record))
+      return publicProjectionRunRecord(record)
+    })
+  }
+
   async startOrReclaim(input: StartOrReclaimProjectionRunInput): Promise<ProjectionRunClaim> {
     return this.runRootOperation(() => {
       assertProjectionRunStartInput(input)
-      this.assertDatasetVersionIsImmutable(input)
-
       const key = projectionRunKey(input.projectId, input.id)
       const existing = this.rows.get(key)
-      const attempt = existing ? planProjectionRunReclaim(existing, input).attempt : 1
-      const executionToken = this.issueExecutionToken(key, input.id, existing?.executionToken)
-      const record: StoredProjectionRunRecord = existing
-        ? { ...existing, attempt, executionToken }
-        : { ...createProjectionRunRecord(input), executionToken }
+      if (!existing) throw projectionRunNotFound(input.projectId, input.id)
+      const attempt = planProjectionRunReclaim(existing, input).attempt
+      const executionToken = this.issueExecutionToken(key, input.id, existing.executionToken)
+      const record: StoredProjectionRunRecord = {
+        ...existing,
+        status: "running",
+        attempt,
+        executionToken,
+        startedAt: existing.startedAt ?? new Date(input.startedAt ?? new Date()),
+        finishedAt: undefined,
+        error: undefined,
+      }
 
       this.rows.set(key, structuredClone(record))
       return createProjectionRunClaim(record)
     })
   }
 
+  async failEnqueue(input: FailProjectionRunEnqueueInput): Promise<ProjectionRunRecord> {
+    return this.runRootOperation(() => {
+      const key = projectionRunKey(input.projectId, input.id)
+      const existing = this.rows.get(key)
+      if (!existing) throw projectionRunNotFound(input.projectId, input.id)
+      const next = failProjectionRunEnqueue(existing, input)
+      this.rows.set(key, structuredClone(next))
+      return publicProjectionRunRecord(next)
+    })
+  }
+
   async lockForMaterialization(
     input: LockProjectionRunForMaterializationInput
   ): Promise<ProjectionRunRecord> {
@@ -232,8 +296,13 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
             : true
         )
         .filter((record) => (statuses ? statuses.has(record.status) : true))
-        .filter((record) => (input.startedAfter ? record.startedAt >= input.startedAfter : true))
-        .filter((record) => (input.startedBefore ? record.startedAt <= input.startedBefore : true))
+        .filter((record) =>
+          matchesRunListDateFilters(record, {
+            statuses,
+            startedAfter: input.startedAfter,
+            startedBefore: input.startedBefore,
+          })
+        )
         .sort((left, right) => compareRuns(left, right, order))
 
       const total = filtered.length
@@ -255,7 +324,7 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
     })
   }
 
-  private assertDatasetVersionIsImmutable(input: StartOrReclaimProjectionRunInput): void {
+  private assertDatasetVersionIsImmutable(input: QueueProjectionRunInput): void {
     for (const candidate of this.rows.values()) {
       if (
         candidate.projectId === input.projectId &&
@@ -292,7 +361,7 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
     input: LockProjectionRunForMaterializationInput
   ): StoredProjectionRunRecord & { readonly executionToken: string } {
     const record = this.requireRunning(input.projectId, input.id)
-    assertProjectionRunExecution(record, input)
+    assertProjectionRunAttempt(record, input)
     return record
   }
 

package/src/storage/projection-runs/index.ts

@@ -2,6 +2,7 @@ export { ProjectionRunError } from "./errors"
 export { InMemoryProjectionRunStorage } from "./in-memory"
 export type {
   AdvanceProjectionTelemetryCheckpointInput,
+  FailProjectionRunEnqueueInput,
   FinishProjectionRunInput,
   LinkProjectionRunRecord,
   LinkProjectionTarget,
@@ -18,18 +19,21 @@ export type {
   ProjectionMaterializationIdentity,
   ProjectionMissingTarget,
   ProjectionRunClaim,
+  ProjectionRunFailureCode,
   ProjectionRunProgress,
   ProjectionRunRecord,
   ProjectionRunStatus,
   ProjectionRunStorage,
   ProjectionTarget,
   ProjectionTelemetryCheckpoint,
+  QueueProjectionRunInput,
   RecordProjectionMissingTargetInput,
   StartOrReclaimProjectionRunInput,
   TelemetryProjectionRunRecord,
   UpdateProjectionRunInput,
 } from "./types"
 export {
+  PROJECTION_RUN_FAILURE_CODES,
   PROJECTION_RUN_PROGRESS_KEYS,
   projectionRunObjectTypesVisible,
   zeroProjectionRunProgress,

package/src/storage/projection-runs/lifecycle.ts

@@ -1,11 +1,19 @@
+import { parseSixbFailure } from "../../errors/internal"
+import type { SixbFailure } from "../../errors/types"
 import type {
   ProjectionMaterializationIdentity,
   ProjectionRunTerminalDecision,
 } from "../../materialization/model"
-import type { ProjectionKind, ProjectionTarget } from "../../projections/types"
+import type {
+  ProjectionKind,
+  ProjectionRunFailureCode,
+  ProjectionTarget,
+} from "../../projections/types"
+import { PROJECTION_RUN_FAILURE_CODES } from "../../projections/types"
 import { ProjectionRunError } from "./errors"
 import type {
   AdvanceProjectionTelemetryCheckpointInput,
+  FailProjectionRunEnqueueInput,
   FinishProjectionRunInput,
   ProjectionMissingTarget,
   ProjectionRunClaim,
@@ -13,6 +21,7 @@ import type {
   ProjectionRunRecord,
   ProjectionRunStatus,
   ProjectionTelemetryCheckpoint,
+  QueueProjectionRunInput,
   StartOrReclaimProjectionRunInput,
   TelemetryProjectionRunRecord,
 } from "./types"
@@ -25,6 +34,7 @@ export type StoredProjectionRunRecord = ProjectionRunRecord & {
 export interface PersistedProjectionRunRecord {
   readonly id: string
   readonly projectId: string
+  readonly executionId: string
   readonly projectionId: string
   readonly projectionKind: ProjectionKind
   readonly protocol?: "replacement" | "telemetry"
@@ -38,7 +48,8 @@ export interface PersistedProjectionRunRecord {
   readonly sourceObjectTypeId?: string
   readonly targetObjectTypeId?: string
   readonly status: ProjectionRunStatus
-  readonly startedAt: Date
+  readonly queuedAt: Date
+  readonly startedAt?: Date
   readonly finishedAt?: Date
   readonly attempt: number
   readonly executionToken?: string
@@ -51,7 +62,7 @@ export interface PersistedProjectionRunRecord {
   readonly missingTargetBatchOrdinal?: number
   readonly missingTargetFirstSeenAt?: Date
   readonly progress: ProjectionRunProgress
-  readonly errorMessage?: string
+  readonly error?: unknown
 }
 
 export interface ProjectionTelemetryAdvance {
@@ -60,11 +71,11 @@ export interface ProjectionTelemetryAdvance {
 }
 
 export interface ProjectionRunFinishPlan {
-  readonly status: Exclude<ProjectionRunStatus, "running">
+  readonly status: Exclude<ProjectionRunStatus, "queued" | "running">
   readonly finishedAt: Date
   readonly progress: ProjectionRunProgress
   readonly inputExhausted?: true
-  readonly errorMessage?: string
+  readonly error?: SixbFailure<ProjectionRunFailureCode>
 }
 
 // ── Scalar and identity validation ──────────────────────────
@@ -145,11 +156,25 @@ export function assertProjectionRunTargetMatches(
 export function assertProjectionRunStartInput(input: StartOrReclaimProjectionRunInput): void {
   assertProjectionRunNonEmpty(input.id, "id")
   assertProjectionRunNonEmpty(input.projectId, "projectId")
+  assertProjectionRunIdentityAndTarget(input)
+  if (input.startedAt) assertProjectionRunDate(input.startedAt, "startedAt")
+}
+
+export function assertProjectionRunQueueInput(input: QueueProjectionRunInput): void {
+  assertProjectionRunNonEmpty(input.id, "id")
+  assertProjectionRunNonEmpty(input.projectId, "projectId")
+  assertProjectionRunNonEmpty(input.executionId, "executionId")
+  assertProjectionRunIdentityAndTarget(input)
+  if (input.queuedAt) assertProjectionRunDate(input.queuedAt, "queuedAt")
+}
+
+function assertProjectionRunIdentityAndTarget(
+  input: QueueProjectionRunInput | StartOrReclaimProjectionRunInput
+): void {
   assertProjectionRunIdentity(input.identity)
   assertProjectionTarget(input.identity.projectionKind, input.target)
-  if (input.startedAt) assertProjectionRunDate(input.startedAt, "startedAt")
   if (input.identity.projectionKind === "telemetry") {
-    const telemetry = input as ProjectionRunStart<"telemetry">
+    const telemetry = input as ProjectionRunIdentityInput<"telemetry">
     assertPositiveCounter(telemetry.fixedBatchSize, "fixedBatchSize")
   } else if (input.fixedBatchSize !== undefined) {
     throw new ProjectionRunError(
@@ -162,7 +187,11 @@ export function planProjectionRunReclaim(
   record: StoredProjectionRunRecord,
   input: StartOrReclaimProjectionRunInput
 ): { readonly attempt: number } {
-  assertProjectionRunRunning(record)
+  if (record.status !== "queued" && record.status !== "running") {
+    throw new ProjectionRunError(
+      `[Sixb] Projection run '${record.id}' cannot start from status '${record.status}'.`
+    )
+  }
   assertProjectionRunIdentityMatches(record, input.identity)
   assertProjectionRunTargetMatches(record, input.target)
   if (record.telemetryCheckpoint?.fixedBatchSize !== input.fixedBatchSize) {
@@ -170,35 +199,36 @@ export function planProjectionRunReclaim(
       `[Sixb] Projection run '${input.id}' fixed batch size does not match.`
     )
   }
-  return { attempt: nextProjectionRunAttempt(record.attempt) }
+  return { attempt: record.status === "queued" ? 1 : nextProjectionRunAttempt(record.attempt) }
 }
 
 // ── Lifecycle transitions ───────────────────────────────────
 
 export function createProjectionRunRecord(
-  input: StartOrReclaimProjectionRunInput,
+  input: QueueProjectionRunInput,
   now: Date = new Date()
 ): ProjectionRunRecord {
-  assertProjectionRunStartInput(input)
+  assertProjectionRunQueueInput(input)
   const base = {
     id: input.id,
     projectId: input.projectId,
-    status: "running" as const,
-    attempt: 1,
+    executionId: input.executionId,
+    status: "queued" as const,
+    attempt: 0,
     progress: zeroProjectionRunProgress(),
-    startedAt: new Date(input.startedAt ?? now),
+    queuedAt: new Date(input.queuedAt ?? now),
   }
   switch (input.identity.projectionKind) {
     case "object": {
-      const object = input as ProjectionRunStart<"object">
+      const object = input as ProjectionRunAdmission<"object">
       return { ...base, identity: object.identity, target: object.target }
     }
     case "link": {
-      const link = input as ProjectionRunStart<"link">
+      const link = input as ProjectionRunAdmission<"link">
       return { ...base, identity: link.identity, target: link.target }
     }
     case "telemetry": {
-      const telemetry = input as ProjectionRunStart<"telemetry">
+      const telemetry = input as ProjectionRunAdmission<"telemetry">
       return {
         ...base,
         identity: telemetry.identity,
@@ -218,12 +248,15 @@ export function assertProjectionRunRunning(
   record: Pick<ProjectionRunRecord, "id" | "projectId" | "status">
 ): void {
   if (record.status === "running") return
+  if (record.status !== "queued") {
+    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' is already terminal.`)
+  }
   throw new ProjectionRunError(
-    `[Sixb] Projection run '${record.id}' for project '${record.projectId}' is already terminal.`
+    `[Sixb] Projection run '${record.id}' for project '${record.projectId}' is not running.`
   )
 }
 
-export function assertProjectionRunExecution(
+export function assertProjectionRunAttempt(
   record: StoredProjectionRunRecord,
   input: {
     readonly id: string
@@ -353,9 +386,9 @@ export function planProjectionRunFinish(
     ...(input.status === "succeeded" && input.protocol === "telemetry"
       ? { inputExhausted: true as const }
       : {}),
-    ...(input.status === "succeeded" || input.errorMessage === undefined
+    ...(input.status === "succeeded" || input.error === undefined
       ? {}
-      : { errorMessage: input.errorMessage }),
+      : { error: parseSixbFailure(input.error, PROJECTION_RUN_FAILURE_CODES) }),
   }
 }
 
@@ -370,7 +403,7 @@ export function finishProjectionRunRecord(
     status: plan.status,
     finishedAt: plan.finishedAt,
     progress: plan.progress,
-    errorMessage: plan.errorMessage,
+    error: plan.error,
   }
   if (plan.inputExhausted) {
     const telemetry = requireTelemetryProjectionRun(record)
@@ -383,36 +416,76 @@ export function finishProjectionRunRecord(
   return { ...record, ...terminal }
 }
 
+export function failProjectionRunEnqueue(
+  record: StoredProjectionRunRecord,
+  input: FailProjectionRunEnqueueInput,
+  now: Date = new Date()
+): StoredProjectionRunRecord {
+  if (record.status !== "queued") {
+    throw new ProjectionRunError(
+      `[Sixb] Projection run '${record.id}' cannot fail enqueue from status '${record.status}'.`
+    )
+  }
+  const error = parseSixbFailure(input.error, PROJECTION_RUN_FAILURE_CODES)
+  if (error.code !== "queue.enqueue_failed") {
+    throw new ProjectionRunError(
+      `[Sixb] Projection run '${record.id}' enqueue failure must use code 'queue.enqueue_failed'.`
+    )
+  }
+  const finishedAt = new Date(input.finishedAt ?? now)
+  assertProjectionRunDate(finishedAt, "finishedAt")
+  return {
+    ...record,
+    status: "failed",
+    finishedAt,
+    error,
+  }
+}
+
+export function canRequeueProjectionRunAfterEnqueueFailure(
+  record: ProjectionRunRecord,
+  input: QueueProjectionRunInput
+): boolean {
+  return (
+    record.status === "failed" &&
+    record.error?.code === "queue.enqueue_failed" &&
+    record.error.retryable &&
+    record.executionId === input.executionId &&
+    projectionRunIdentitiesEqual(record.identity, input.identity) &&
+    projectionTargetsEqual(record.target, input.target) &&
+    record.telemetryCheckpoint?.fixedBatchSize === input.fixedBatchSize
+  )
+}
+
 // ── Persistence mapping ─────────────────────────────────────
 
 export function restoreProjectionRun(row: PersistedProjectionRunRecord): StoredProjectionRunRecord {
   assertProjectionRunNonEmpty(row.id, "id")
   assertProjectionRunNonEmpty(row.projectId, "projectId")
+  assertProjectionRunNonEmpty(row.executionId, "executionId")
   assertProjectionRunCounter(row.attempt, "attempt")
-  if (row.attempt < 1) {
-    throw new ProjectionRunError(`[Sixb] Projection run '${row.id}' attempt must be positive.`)
-  }
   assertProjectionRunProgress(row.progress)
-  assertValidDate(row.startedAt, "startedAt")
+  assertValidDate(row.queuedAt, "queuedAt")
+  if (row.startedAt) assertValidDate(row.startedAt, "startedAt")
   if (row.finishedAt) assertValidDate(row.finishedAt, "finishedAt")
-  if ((row.status === "running") !== (row.finishedAt === undefined)) {
-    throw incompleteProjectionRun(row.id)
-  }
-  if ((row.status === "running") !== (row.executionToken !== undefined)) {
-    throw incompleteProjectionRun(row.id)
-  }
+  assertPersistedLifecycle(row)
 
   const identity = restoreIdentity(row)
   const base = {
     id: row.id,
     projectId: row.projectId,
+    executionId: row.executionId,
     identity,
     status: row.status,
-    startedAt: new Date(row.startedAt),
+    queuedAt: new Date(row.queuedAt),
+    startedAt: row.startedAt ? new Date(row.startedAt) : undefined,
     finishedAt: row.finishedAt ? new Date(row.finishedAt) : undefined,
     attempt: row.attempt,
     progress: { ...row.progress },
-    errorMessage: row.errorMessage,
+    error:
+      row.error === undefined
+        ? undefined
+        : parseSixbFailure(row.error, PROJECTION_RUN_FAILURE_CODES),
     executionToken: row.executionToken,
   }
 
@@ -522,6 +595,57 @@ function assertValidDate(value: Date, fieldName: string): void {
   }
 }
 
+function assertPersistedLifecycle(row: PersistedProjectionRunRecord): void {
+  const hasError = row.error !== undefined
+
+  if (row.status === "queued") {
+    if (
+      row.attempt !== 0 ||
+      row.startedAt !== undefined ||
+      row.finishedAt !== undefined ||
+      row.executionToken !== undefined ||
+      hasError
+    ) {
+      throw incompleteProjectionRun(row.id)
+    }
+    return
+  }
+
+  if (row.status === "running") {
+    if (
+      row.attempt < 1 ||
+      row.startedAt === undefined ||
+      row.finishedAt !== undefined ||
+      row.executionToken === undefined ||
+      hasError
+    ) {
+      throw incompleteProjectionRun(row.id)
+    }
+    return
+  }
+
+  if (row.finishedAt === undefined || row.executionToken !== undefined) {
+    throw incompleteProjectionRun(row.id)
+  }
+  if (row.error !== undefined) {
+    const failure = parseSixbFailure(row.error, PROJECTION_RUN_FAILURE_CODES)
+    if (failure.code === "queue.enqueue_failed") {
+      if (
+        !failure.retryable ||
+        row.status !== "failed" ||
+        row.attempt !== 0 ||
+        row.startedAt !== undefined
+      ) {
+        throw incompleteProjectionRun(row.id)
+      }
+      return
+    }
+  }
+  if (row.attempt < 1 || row.startedAt === undefined || (row.status === "succeeded" && hasError)) {
+    throw incompleteProjectionRun(row.id)
+  }
+}
+
 function assertProjectionRunDate(value: Date, fieldName: string): void {
   if (!Number.isFinite(value.getTime())) {
     throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} is invalid.`)
@@ -781,8 +905,13 @@ export function requireTelemetryProjectionRun<TRecord extends ProjectionRunRecor
   )
 }
 
-type ProjectionRunStart<TKind extends ProjectionKind> = Extract<
-  StartOrReclaimProjectionRunInput,
+type ProjectionRunIdentityInput<TKind extends ProjectionKind> = Extract<
+  QueueProjectionRunInput | StartOrReclaimProjectionRunInput,
+  { readonly identity: { readonly projectionKind: TKind } }
+>
+
+type ProjectionRunAdmission<TKind extends ProjectionKind> = Extract<
+  QueueProjectionRunInput,
   { readonly identity: { readonly projectionKind: TKind } }
 >
 

package/src/storage/projection-runs/provider.ts

@@ -0,0 +1,34 @@
+import type { ExecutionStorage } from "../executions"
+import { findPrimitiveRunExecution } from "../executions/run-link"
+import { ProjectionRunError } from "./errors"
+
+export * from "./lifecycle"
+
+/** Validate the semantic link between a durable Projection run and its immutable execution. */
+export async function assertProjectionRunDurableExecution(input: {
+  readonly executions: ExecutionStorage
+  readonly projectId: string
+  readonly executionId: string
+  readonly runId: string
+  readonly projectionId: string
+  readonly datasetId: string
+  readonly datasetVersionId: string
+}): Promise<void> {
+  const execution = await findPrimitiveRunExecution({
+    executions: input.executions,
+    projectId: input.projectId,
+    executionId: input.executionId,
+    primitive: { kind: "projection", id: input.projectionId, runId: input.runId },
+    sourceTypes: ["datasetVersion"],
+  })
+  if (
+    !execution ||
+    execution.source.type !== "datasetVersion" ||
+    execution.source.datasetId !== input.datasetId ||
+    execution.source.versionId !== input.datasetVersionId
+  ) {
+    throw new ProjectionRunError(
+      `[Sixb] Execution '${input.executionId}' does not authorize Projection run '${input.runId}'.`
+    )
+  }
+}