@sixb/core 0.1.1 → 0.1.3

package/src/objects/service/action-service.ts

@@ -5,6 +5,7 @@
  */
 
 import type { RequestActionResult } from "../../actions/request"
+import type { ExecutionContext } from "../../execution"
 import type { SixbRuntimeContext } from "../../runtime/types"
 import type { ActionRunRecord } from "../../storage"
 import {
@@ -17,24 +18,26 @@ import { resolveObjectContext } from "../context"
 
 export async function requestAction(
   runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
   objectTypeId: string,
   primaryId: string,
   actionId: string,
   params?: Record<string, unknown>,
   options?: RequestActionOptions
 ): Promise<RequestActionResult> {
-  const ctx = resolveObjectContext(runtime, objectTypeId)
+  const ctx = { ...resolveObjectContext(runtime, objectTypeId), execution }
   return requestActionLeaf(ctx, { primaryId, actionId, params, options })
 }
 
 export async function requestActionAndWait(
   runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
   objectTypeId: string,
   primaryId: string,
   actionId: string,
   params?: Record<string, unknown>,
   options?: RequestActionAndWaitOptions
 ): Promise<ActionRunRecord> {
-  const ctx = resolveObjectContext(runtime, objectTypeId)
+  const ctx = { ...resolveObjectContext(runtime, objectTypeId), execution }
   return requestActionAndWaitLeaf(ctx, { primaryId, actionId, params, options })
 }

package/src/objects/service/list-service.ts

@@ -1,7 +1,7 @@
 /**
  * Cross-type object listing for dashboards and search.
  *
- * On scoped runtimes the type filter is authorized before the storage call:
+ * On principal-bound runtimes the type filter is authorized before the storage call:
  * explicitly requested types must all be viewable, and unfiltered listings
  * narrow to the principal's viewable types instead of post-filtering rows.
  */

package/src/objects/telemetry/history.ts

@@ -1,4 +1,5 @@
 import { type AuthorizationContext, assertAuthorized } from "../../authorization"
+import type { RuntimeAuthorization } from "../../execution"
 import type {
   TimeseriesHistoryBatchInput,
   TimeseriesHistoryBatchResult,
@@ -8,6 +9,7 @@ import type {
 
 export interface TelemetryHistoryOptions {
   readonly storage: TimeseriesStorage
+  readonly runtimeAuthorization?: RuntimeAuthorization
   readonly authorization?: AuthorizationContext | null
 }
 
@@ -15,17 +17,20 @@ export async function getTelemetryHistoryBatch(
   input: TimeseriesHistoryBatchInput,
   options: TelemetryHistoryOptions
 ): Promise<readonly TimeseriesHistoryBatchResult[]> {
-  assertTelemetrySeriesViewable(input.series, options.authorization)
+  assertTelemetrySeriesViewable(input.series, options)
   return options.storage.getHistoryBatch(input)
 }
 
 function assertTelemetrySeriesViewable(
   series: readonly TimeseriesHistorySeriesInput[],
-  authorization: AuthorizationContext | null | undefined
+  authorization: Pick<TelemetryHistoryOptions, "authorization" | "runtimeAuthorization">
 ): void {
   for (const objectTypeId of new Set(series.map((entry) => entry.objectTypeId))) {
     assertAuthorized(
-      { authorization: authorization ?? undefined },
+      {
+        runtimeAuthorization: authorization.runtimeAuthorization,
+        authorization: authorization.authorization ?? undefined,
+      },
       { kind: "object.view", objectTypeId }
     )
   }

package/src/objects/telemetry/write-batch.ts

@@ -34,8 +34,6 @@ export async function writeTelemetryBatch(
   try {
     commit = await getOntologyMutationRuntime(ctx).appendTelemetry({
       source: { kind: "runtime", requestId: randomUUID() },
-      // A `Principal` is an `EventActor` — same literals, no translation.
-      ...(ctx.authorization === undefined ? {} : { actor: ctx.authorization.principal }),
       points,
     })
   } catch (error) {

package/src/ontology/index.ts

@@ -55,7 +55,12 @@ export type {
 
 // ── Registry ──────────────────────────────────────────────
 
-export type { OntologyDocumentInput, OntologyRegistryOptions, OntologySource } from "./registry"
+export type {
+  OntologyDefinitionCatalog,
+  OntologyDocumentInput,
+  OntologyRegistryOptions,
+  OntologySource,
+} from "./registry"
 export { OntologyRegistry } from "./registry"
 
 // ── Errors ─────────────────────────────────────────────────

package/src/ontology/registry.ts

@@ -2,7 +2,7 @@
  * Standalone ontology registry — owns all type state and resolution logic.
  *
  * Zero infrastructure dependencies: imports only from the `ontology/` module.
- * Other modules depend on `OntologyRegistry` instead of coupling to the full
+ * Other modules depend on its read-only catalog instead of coupling to the full
  * `Sixb` facade.
  */
 
@@ -40,6 +40,20 @@ export interface OntologyRegistryOptions {
   readonly sources: readonly OntologySource[]
 }
 
+/** Read-only access to the host's validated ontology definitions and type graph. */
+export interface OntologyDefinitionCatalog {
+  listObjectTypes(): readonly ObjectTypeWithPropertyTokens[]
+  getObjectTypeById(objectTypeId: string): ObjectTypeWithPropertyTokens | null
+  resolveObjectType(objectTypeId: string): ObjectTypeWithPropertyTokens
+  getPrimaryPropertyId(objectTypeId: string): string
+  listSubTypes(objectTypeId: string): string[]
+  listAncestorChain(objectType: ObjectType): readonly ObjectTypeWithPropertyTokens[]
+  isValidLinkTarget(expected: string | string[], actual: string): boolean
+  getObjectTypesById(): ReadonlyMap<string, ObjectTypeWithPropertyTokens>
+  getValueTypesById(): ReadonlyMap<string, ValueType>
+  getPrimaryByTypeId(): ReadonlyMap<string, string>
+}
+
 // ── Private helpers ──────────────────────────────────────────
 
 function isOntologyDocumentSource(
@@ -156,7 +170,7 @@ function collectOntology(sources: readonly OntologySource[]): {
  *
  * Exposes read-only accessors so consumers never mutate ontology state.
  */
-export class OntologyRegistry {
+export class OntologyRegistry implements OntologyDefinitionCatalog {
   private readonly objectTypesById = new Map<string, ObjectTypeWithPropertyTokens>()
   private readonly valueTypesById = new Map<string, ValueType>()
   private readonly subTypesById = new Map<string, Set<string>>()

package/src/pipelines/execution.ts

@@ -0,0 +1,105 @@
+import { canViewPipelineRun, isAllowed } from "../authorization"
+import type { ExecutionContext } from "../execution"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type {
+  ListLatestPipelineRunsResult,
+  ListPipelineRunsInput,
+  ListPipelineRunsResult,
+  ListPipelineStepRunsInput,
+  ListPipelineStepRunsResult,
+  PipelineRunRecord,
+} from "../storage/pipeline-runs"
+import { PipelineError } from "./errors"
+import {
+  type PipelineRunRequestResult,
+  type RequestPipelineRunInput,
+  requestPipelineRun,
+} from "./request"
+import type { PipelineDefinition } from "./types"
+
+export interface PipelineRunsRuntime {
+  getById(runId: string): Promise<PipelineRunRecord | null>
+  list(
+    input?: Omit<ListPipelineRunsInput, "projectId" | "pipelineIds">
+  ): Promise<ListPipelineRunsResult>
+  listLatest(pipelineIds: readonly string[]): Promise<ListLatestPipelineRunsResult>
+  listSteps(
+    runId: string,
+    input?: Omit<ListPipelineStepRunsInput, "projectId" | "pipelineRunId">
+  ): Promise<ListPipelineStepRunsResult | null>
+}
+
+export interface PipelinesRuntime {
+  list(): readonly PipelineDefinition[]
+  getById(pipelineId: string): PipelineDefinition | null
+  request(input: RequestPipelineRunInput): Promise<PipelineRunRequestResult>
+  readonly runs: PipelineRunsRuntime
+}
+
+export function createPipelinesRuntime(
+  runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
+  source: Pick<PipelinesRuntime, "list" | "getById">
+): PipelinesRuntime {
+  const allowed = (pipelineId: string) =>
+    isAllowed(runtime.authorization, { kind: "pipeline.run", pipelineId })
+  const visibleIds = () =>
+    source
+      .list()
+      .filter((pipeline) => allowed(pipeline.id))
+      .map((pipeline) => pipeline.id)
+
+  const getRun = async (runId: string) => {
+    const run =
+      (await runtime.storage.pipelineRuns?.getById({
+        projectId: runtime.projectId,
+        id: runId,
+      })) ?? null
+    return run && canViewPipelineRun(runtime.authorization, run) ? run : null
+  }
+
+  return {
+    list: () => source.list().filter((pipeline) => allowed(pipeline.id)),
+    getById: (pipelineId) => {
+      const pipeline = source.getById(pipelineId)
+      return pipeline && allowed(pipelineId) ? pipeline : null
+    },
+    request: async (input) => {
+      const pipeline = source.getById(input.pipelineId)
+      if (!pipeline) throw new PipelineError(`[Sixb] Unknown pipeline '${input.pipelineId}'`)
+      return requestPipelineRun(runtime, execution, pipeline, input)
+    },
+    runs: {
+      getById: getRun,
+      list: (input = {}) => {
+        const storage = runtime.storage.pipelineRuns
+        if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        return storage.list({
+          projectId: runtime.projectId,
+          ...input,
+          pipelineIds: runtime.authorization ? visibleIds() : undefined,
+        })
+      },
+      listLatest: (pipelineIds) => {
+        const storage = runtime.storage.pipelineRuns
+        if (!storage || pipelineIds.length === 0) return Promise.resolve({ runs: [] })
+        const allowedIds = pipelineIds.filter(allowed)
+        return allowedIds.length === 0
+          ? Promise.resolve({ runs: [] })
+          : storage.listLatestByPipelineIds({
+              projectId: runtime.projectId,
+              pipelineIds: allowedIds,
+            })
+      },
+      listSteps: async (runId, input = {}) => {
+        const storage = runtime.storage.pipelineRuns
+        if (!storage || !(await getRun(runId))) return null
+        return storage.listSteps({
+          projectId: runtime.projectId,
+          ...input,
+          pipelineRunId: runId,
+        })
+      },
+    },
+  }
+}

package/src/pipelines/index.ts

@@ -6,6 +6,13 @@ export type {
   RequestPipelineRunInput,
 } from "./request"
 export { requestPipelineRun } from "./request"
+export {
+  type AutomaticPipelineExecutionSource,
+  type AutomaticPipelineRunDispatchInput,
+  PipelineRunDispatcher,
+  type PipelineRunDispatcherDependencies,
+  type PipelineRunDispatchPort,
+} from "./run-dispatch"
 export type {
   PipelineBuilder,
   PipelineDefinition,

package/src/pipelines/request.ts

@@ -1,15 +1,17 @@
-import { randomUUID } from "node:crypto"
 import { assertAuthorized } from "../authorization"
+import {
+  createPrimitiveExecutionRecord,
+  ensureExecutionRecord,
+  executionRecordInputFromRuntime,
+} from "../execution/durable"
+import type { ExecutionContext } from "../execution/types"
 import type { SixbRuntimeContext } from "../runtime/types"
 import { PipelineError } from "./errors"
+import { dispatchPipelineRun } from "./run-dispatch"
 import type { PipelineDefinition } from "./types"
 
 export interface PipelineRunRequestOptions {
-  /**
-   * Identity of the run to create. Deduplicated when a worker claims the job, not here: two requests
-   * carrying the same id enqueue two jobs, and the second loses to the unique run id. So one run
-   * happens, but this call cannot tell you whether it was yours.
-   */
+  /** Stable identity used to make dispatch idempotent. */
   readonly runId?: string
 }
 
@@ -20,9 +22,10 @@ export interface RequestPipelineRunInput extends PipelineRunRequestOptions {
 export interface PipelineRunRequestResult {
   readonly pipelineId: string
   readonly runId: string
-  /** When the job was enqueued. Not persisted — the run row records `startedAt` instead. */
+  /** Durable time at which the run entered the queue. */
   readonly queuedAt: string
   readonly jobId?: string
+  readonly created: boolean
 }
 
 /**
@@ -31,11 +34,11 @@ export interface PipelineRunRequestResult {
  * Operates on an already-resolved definition and the shared runtime context, so the HTTP route and
  * the runtime verb cannot drift apart.
  *
- * Like `requestSyncRun` and unlike `requestWorkflowRun`, the run row is created by the worker that
- * claims the job — see the note there for why the two cannot be aligned by adding a field.
+ * The immutable child execution and queued run are persisted before queue publication.
  */
 export async function requestPipelineRun(
   runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
   pipeline: PipelineDefinition,
   options: PipelineRunRequestOptions = {}
 ): Promise<PipelineRunRequestResult> {
@@ -49,23 +52,26 @@ export async function requestPipelineRun(
     throw new PipelineError("[Sixb] Pipeline run queue is not configured.")
   }
 
-  const runId = createPipelineRunId(options.runId)
-  const queuedAt = new Date().toISOString()
-  const [job] = await queue.enqueue({
+  return dispatchPipelineRun({
+    errorReporterHost: runtime,
     projectId: runtime.projectId,
-    jobs: [{ type: "pipeline.run.requested", payload: { pipelineId: pipeline.id, runId } }],
+    pipeline,
+    storage: runtime.storage,
+    queue,
+    ...options,
+    createExecution: async (executionId, runId) => {
+      const caller = await ensureExecutionRecord(
+        runtime.storage.executions,
+        executionRecordInputFromRuntime({
+          execution,
+          runtimeAuthorization: runtime.runtimeAuthorization,
+        })
+      )
+      return createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "pipeline", id: pipeline.id, runId },
+        origin: { type: "execution", parent: caller },
+      })
+    },
   })
-
-  return { pipelineId: pipeline.id, runId, queuedAt, jobId: job?.id }
-}
-
-function createPipelineRunId(runId: string | undefined): string {
-  if (runId !== undefined) {
-    if (!runId.trim()) {
-      throw new PipelineError("[Sixb] Pipeline run id must not be empty")
-    }
-    return runId
-  }
-
-  return `run_${randomUUID()}`
 }

package/src/pipelines/run-dispatch.ts

@@ -0,0 +1,308 @@
+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 { Queues } from "../queues"
+import type { SixbDefinitions } from "../runtime/definitions"
+import type {
+  CreateExecutionInput,
+  PipelineRunFailureCode,
+  PipelineRunRecord,
+  Storage,
+} from "../storage"
+import { PIPELINE_RUN_FAILURE_CODES, PipelineRunError } from "../storage"
+import { PipelineError } from "./errors"
+import type { PipelineRunRequestOptions, PipelineRunRequestResult } from "./request"
+import type { PipelineDefinition } from "./types"
+
+export type AutomaticPipelineExecutionSource =
+  | { readonly type: "schedule"; readonly eventId: string }
+  | { readonly type: "event"; readonly eventId: string }
+
+export interface AutomaticPipelineRunDispatchInput extends PipelineRunRequestOptions {
+  readonly pipelineId: string
+  readonly runId: string
+  readonly source: AutomaticPipelineExecutionSource
+  readonly correlationId: string
+  readonly metadata?: Readonly<Record<string, string>>
+}
+
+export type PipelineRunDispatchPort = RunDispatcher<
+  AutomaticPipelineRunDispatchInput,
+  PipelineRunRequestResult
+>
+
+export interface PipelineRunDispatcherDependencies {
+  readonly id: string
+  readonly definitions: Pick<SixbDefinitions, "pipelines">
+  readonly storage: Storage
+  readonly queues: Pick<Queues, "pipelines">
+}
+
+interface DispatchPipelineRunInput extends PipelineRunRequestOptions {
+  readonly errorReporterHost: object
+  readonly projectId: string
+  readonly pipeline: PipelineDefinition
+  readonly storage: Storage
+  readonly queue: Queues["pipelines"]
+  readonly metadata?: Readonly<Record<string, string>>
+  readonly createExecution: (executionId: string, runId: string) => Promise<CreateExecutionInput>
+  readonly validateExistingRun?: (run: PipelineRunRecord, storage: Storage) => Promise<void>
+}
+
+type PersistedPipelineRun =
+  | { readonly publish: false; readonly run: PipelineRunRecord }
+  | {
+      readonly publish: true
+      readonly run: PipelineRunRecord
+      readonly execution: CreateExecutionInput
+      readonly queuedAt: Date
+      readonly created: boolean
+    }
+
+/** Core-owned durable dispatch boundary used by automatic Pipeline triggers. */
+export class PipelineRunDispatcher implements PipelineRunDispatchPort {
+  constructor(private readonly dependencies: PipelineRunDispatcherDependencies) {}
+
+  async dispatch(input: AutomaticPipelineRunDispatchInput): Promise<PipelineRunRequestResult> {
+    assertAutomaticDispatchInput(input)
+    const pipeline = this.dependencies.definitions.pipelines.getById(input.pipelineId)
+    if (!pipeline) throw new PipelineError(`[Sixb] Unknown pipeline '${input.pipelineId}'`)
+
+    return dispatchPipelineRun({
+      errorReporterHost: this.dependencies,
+      projectId: this.dependencies.id,
+      pipeline,
+      storage: this.dependencies.storage,
+      queue: this.dependencies.queues.pipelines,
+      runId: input.runId,
+      metadata: input.metadata,
+      validateExistingRun: (run, storage) =>
+        assertAutomaticExecutionIdentity(storage, this.dependencies.id, input, run),
+      createExecution: async (executionId, runId) =>
+        createPrimitiveExecutionRecord({
+          id: executionId,
+          primitive: { kind: "pipeline", id: pipeline.id, runId },
+          origin: {
+            type: "automatic",
+            projectId: this.dependencies.id,
+            source: input.source,
+            correlationId: input.correlationId,
+          },
+        }),
+    })
+  }
+}
+
+/** Persist a Pipeline execution and queued run before publishing its queue job. */
+export async function dispatchPipelineRun(
+  input: DispatchPipelineRunInput
+): Promise<PipelineRunRequestResult> {
+  const runId = createPipelineRunId(input.runId)
+  const persisted = await persistPipelineRun(input, runId)
+  if (!persisted.publish) return existingPipelineRunResult(persisted.run)
+  return publishPipelineRun(input, persisted)
+}
+
+async function persistPipelineRun(
+  input: DispatchPipelineRunInput,
+  runId: string
+): Promise<PersistedPipelineRun> {
+  const pipelineRuns = requirePipelineRunStorage(input.storage)
+  const existing = await pipelineRuns.getById({ projectId: input.projectId, id: runId })
+  if (existing) return reusePipelineRun(input, existing)
+
+  const execution = await input.createExecution(`exec_${randomUUID()}`, runId)
+  const queuedAt = new Date()
+  try {
+    return await input.storage.transaction(
+      async (tx): Promise<PersistedPipelineRun> => {
+        const transactionalRuns = requirePipelineRunStorage(tx)
+        const raced = await transactionalRuns.getById({ projectId: input.projectId, id: runId })
+        if (raced) {
+          assertExistingRunMatchesRequest(raced, input)
+          await input.validateExistingRun?.(raced, tx)
+          return { publish: false, run: raced }
+        }
+
+        await tx.executions.create(execution)
+        const run = await transactionalRuns.queue({
+          projectId: input.projectId,
+          id: runId,
+          executionId: execution.id,
+          pipelineId: input.pipeline.id,
+          queuedAt,
+        })
+        return { publish: true, run, execution, queuedAt, created: true }
+      },
+      { isolation: "serializable" }
+    )
+  } catch (error) {
+    if (!(error instanceof PipelineRunError)) throw error
+    const raced = await pipelineRuns.getById({ projectId: input.projectId, id: runId })
+    if (!raced) throw error
+    assertExistingRunMatchesRequest(raced, input)
+    await input.validateExistingRun?.(raced, input.storage)
+    return { publish: false, run: raced }
+  }
+}
+
+async function reusePipelineRun(
+  input: DispatchPipelineRunInput,
+  existing: PipelineRunRecord
+): Promise<PersistedPipelineRun> {
+  assertExistingRunMatchesRequest(existing, input)
+  await input.validateExistingRun?.(existing, input.storage)
+  if (
+    existing.status !== "failed" ||
+    existing.error?.code !== "queue.enqueue_failed" ||
+    !existing.error.retryable
+  ) {
+    return { publish: false, run: existing }
+  }
+
+  const execution = await input.storage.executions.getById({
+    projectId: input.projectId,
+    id: existing.executionId,
+  })
+  if (!execution) {
+    throw new PipelineRunError(
+      `[Sixb] Execution '${existing.executionId}' for Pipeline run '${existing.id}' was not found.`
+    )
+  }
+
+  const queuedAt = new Date()
+  const run = await requirePipelineRunStorage(input.storage).queue({
+    projectId: input.projectId,
+    id: existing.id,
+    executionId: existing.executionId,
+    pipelineId: existing.pipelineId,
+    queuedAt,
+  })
+  return { publish: true, run, execution, queuedAt, created: false }
+}
+
+async function publishPipelineRun(
+  input: DispatchPipelineRunInput,
+  persisted: Extract<PersistedPipelineRun, { readonly publish: true }>
+): Promise<PipelineRunRequestResult> {
+  try {
+    const [job] = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: [
+        {
+          id: persisted.run.id,
+          type: "pipeline.run.requested",
+          payload: { runId: persisted.run.id },
+          ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+        },
+      ],
+    })
+    return {
+      pipelineId: persisted.run.pipelineId,
+      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 requirePipelineRunStorage(input.storage).finish({
+      projectId: input.projectId,
+      id: persisted.run.id,
+      status: "failed",
+      finishedAt: failedAt,
+      error: failure,
+    })
+    reportRunFailure(input.errorReporterHost, error, {
+      projectId: input.projectId,
+      runKind: "pipeline",
+      run: { runId: failed.id, pipelineId: failed.pipelineId },
+      failure,
+    })
+    throw error
+  }
+}
+
+function assertExistingRunMatchesRequest(
+  existing: PipelineRunRecord,
+  input: Pick<DispatchPipelineRunInput, "pipeline">
+): void {
+  if (existing.pipelineId !== input.pipeline.id) {
+    throw new PipelineRunError(
+      `[Sixb] Pipeline run '${existing.id}' already exists with a different request payload.`
+    )
+  }
+}
+
+function existingPipelineRunResult(existing: PipelineRunRecord): PipelineRunRequestResult {
+  return {
+    pipelineId: existing.pipelineId,
+    runId: existing.id,
+    queuedAt: existing.queuedAt.toISOString(),
+    created: false,
+  }
+}
+
+function requirePipelineRunStorage(storage: Storage): NonNullable<Storage["pipelineRuns"]> {
+  if (!storage.pipelineRuns) {
+    throw new PipelineError("[Sixb] Pipeline run storage is not configured.")
+  }
+  return storage.pipelineRuns
+}
+
+function createPipelineRunId(runId: string | undefined): string {
+  if (runId === undefined) return `run_${randomUUID()}`
+  if (!runId.trim()) throw new PipelineError("[Sixb] Pipeline run id must not be empty")
+  return runId
+}
+
+function assertAutomaticDispatchInput(input: AutomaticPipelineRunDispatchInput): void {
+  assertNonBlank(input.pipelineId, "Pipeline id")
+  assertNonBlank(input.runId, "Pipeline run id")
+  assertNonBlank(input.source.eventId, "Pipeline source event id")
+  assertNonBlank(input.correlationId, "Pipeline correlation id")
+}
+
+async function assertAutomaticExecutionIdentity(
+  storage: Storage,
+  projectId: string,
+  input: AutomaticPipelineRunDispatchInput,
+  run: PipelineRunRecord
+): Promise<void> {
+  const execution = await storage.executions.getById({ projectId, id: run.executionId })
+  if (
+    !execution ||
+    execution.source.type !== input.source.type ||
+    execution.source.eventId !== input.source.eventId ||
+    execution.correlationId !== input.correlationId ||
+    execution.requestedBy !== undefined
+  ) {
+    throw new PipelineError(
+      `[Sixb] Pipeline run '${run.id}' already exists with different automatic provenance.`
+    )
+  }
+}
+
+function toEnqueueFailure(
+  error: unknown,
+  run: PipelineRunRecord,
+  at: Date
+): SixbFailure<PipelineRunFailureCode> {
+  const enqueueError = createSixbError(
+    "queue.enqueue_failed",
+    `[Sixb] Could not enqueue Pipeline run '${run.id}'.`,
+    {
+      cause: error,
+      details: { pipelineId: run.pipelineId, runId: run.id, phase: "enqueue" },
+    }
+  )
+  return toSixbFailure(enqueueError, { allowedCodes: PIPELINE_RUN_FAILURE_CODES, at })
+}
+
+function assertNonBlank(value: string, label: string): void {
+  if (!value.trim()) throw new PipelineError(`[Sixb] ${label} must not be empty.`)
+}