@sixb/core 0.0.1

package/src/storage/types.ts

@@ -0,0 +1,299 @@
+import type { ActionRunStorage } from "./action-runs"
+import type { AgentStorage } from "./agents"
+import type { AuthStorage } from "./auth"
+import type { FileUploadSessionStore } from "./file-upload-sessions"
+import type { ObjectStorage } from "./objects/types"
+import type { OntologyStorage } from "./ontology"
+import type { PipelineRunStorage } from "./pipeline-runs"
+import type { ProjectionRunStorage } from "./projection-runs"
+import type { RulesStorage } from "./rules"
+import type { SyncRunStorage } from "./sync-runs"
+import type { TimeseriesStorage } from "./timeseries/types"
+import type { WebhookDeliveryStorage } from "./webhook-deliveries"
+import type { WebhookRunStorage } from "./webhook-runs"
+import type { WorkflowInterventionStorage } from "./workflow-interventions"
+import type { WorkflowRunStorage } from "./workflow-runs"
+
+export type {
+  PinnedDatasetVersion,
+  ProjectionExecution,
+  ProjectionMaterializationIdentity,
+} from "../materialization/model"
+export type {
+  ActionRunFailure,
+  ActionRunParams,
+  ActionRunPhase,
+  ActionRunRecord,
+  ActionRunStatus,
+  ActionRunStorage,
+  FinishActionRunInput,
+  ListActionRunsInput,
+  ListActionRunsResult,
+  LockActionMaterializationRunInput,
+  QueueActionRunInput,
+  StartActionRunInput,
+} from "./action-runs"
+export { ActionRunError } from "./action-runs"
+export type {
+  AgentMessageRecord,
+  AgentRunExecution,
+  AgentRunRecord,
+  AgentStorage,
+  AgentThreadRecord,
+  AppendAgentMessageInput,
+  ConfirmAgentRunExecutionOwnershipInput,
+  CreateAgentRunInput,
+  CreateAgentThreadInput,
+  FinishAgentRunInput,
+  FinishQueuedAgentRunInput,
+  ListAgentMessagesInput,
+  ListAgentMessagesResult,
+  ListAgentRunsInput,
+  ListAgentRunsResult,
+  ListAgentThreadsInput,
+  ListAgentThreadsResult,
+  ReclaimAgentRunInput,
+  StartAgentRunInput,
+} from "./agents"
+export { AgentStorageError } from "./agents"
+export type {
+  AuthGroupMembershipStore,
+  AuthInvitationStore,
+  AuthMagicLinkStore,
+  AuthOidcAuthorizationAttemptStore,
+  AuthSessionStore,
+  AuthStorage,
+  AuthStorageErrorCode,
+  AuthUserIdentityStore,
+  AuthUserStore,
+  CompleteAuthSessionInput,
+  CompleteMagicLinkSignInInput,
+  CompleteOidcSignInInput,
+  CompleteSignInResult,
+  CreateAuthMagicLinkInput,
+  CreateAuthSessionInput,
+  CreateAuthUserInput,
+  CreateOidcAuthorizationAttemptInput,
+  CreateOrUpdateAuthInvitationInput,
+  GroupMembershipRecord,
+  GroupMembershipSource,
+  InvitationRecord,
+  InvitationStatus,
+  ListAuthInvitationsInput,
+  ListAuthInvitationsResult,
+  ListAuthUsersInput,
+  ListAuthUsersResult,
+  MagicLinkRecord,
+  OidcAuthorizationAttemptRecord,
+  ReconcileAuthServiceAccountGroupMembershipsInput,
+  SessionRecord,
+  SuspendUserAndRevokeSessionsInput,
+  UpdateAuthUserProfileInput,
+  UpdateAuthUserStatusInput,
+  UpsertAuthGroupMembershipInput,
+  UpsertAuthUserIdentityInput,
+  UserIdentityRecord,
+  UserRecord,
+  UserStatus,
+} from "./auth"
+export { AuthStorageError } from "./auth"
+export type { StorageTransactionErrorCode, StorageTransactionErrorOptions } from "./errors"
+export {
+  isStorageSerializationFailure,
+  ObjectStorageError,
+  StorageTransactionError,
+} from "./errors"
+export type {
+  CreateFileUploadSessionInput,
+  FileUploadSession,
+  FileUploadSessionStore,
+  FileUploadStatus,
+  FileUploadStrategy,
+} from "./file-upload-sessions"
+export { FileUploadSessionError } from "./file-upload-sessions"
+export type {
+  LinkDirection,
+  ObjectLinkRow,
+  ObjectQueryCapabilities,
+  ObjectQueryCapabilityMap,
+  ObjectRow,
+  ObjectStorage,
+  QueryObjectsInput,
+  QueryObjectsResult,
+} from "./objects/types"
+export type {
+  FinishPipelineRunInput,
+  FinishPipelineStepRunInput,
+  ListPipelineRunsInput,
+  ListPipelineRunsResult,
+  ListPipelineStepRunsInput,
+  ListPipelineStepRunsResult,
+  PipelineRunFailure,
+  PipelineRunRecord,
+  PipelineRunStatus,
+  PipelineRunStorage,
+  PipelineStepRunRecord,
+  StartPipelineRunInput,
+  StartPipelineStepRunInput,
+} from "./pipeline-runs"
+export { PipelineRunError } from "./pipeline-runs"
+export type {
+  AdvanceProjectionTelemetryCheckpointInput,
+  FinishProjectionRunInput,
+  LinkProjectionRunRecord,
+  LinkProjectionTarget,
+  ListProjectionRunsInput,
+  ListProjectionRunsResult,
+  LockProjectionRunForMaterializationInput,
+  ObjectProjectionRunRecord,
+  ObjectProjectionTarget,
+  ProjectionKind,
+  ProjectionRunClaim,
+  ProjectionRunProgress,
+  ProjectionRunRecord,
+  ProjectionRunStatus,
+  ProjectionRunStorage,
+  ProjectionTarget,
+  ProjectionTelemetryCheckpoint,
+  StartOrReclaimProjectionRunInput,
+  TelemetryProjectionRunRecord,
+  UpdateProjectionRunInput,
+} from "./projection-runs"
+export { ProjectionRunError } from "./projection-runs"
+export type {
+  ListActiveRuleStatesInput,
+  ListActiveRuleStatesResult,
+  RuleStateRecord,
+  RulesStorage,
+} from "./rules"
+export type {
+  FinishSyncRunInput,
+  ListSyncRunsInput,
+  ListSyncRunsResult,
+  StartSyncRunInput,
+  SyncRunFailure,
+  SyncRunRecord,
+  SyncRunStatus,
+  SyncRunStorage,
+} from "./sync-runs"
+export { SyncRunError } from "./sync-runs"
+export type {
+  TimeseriesHistoryBatchInput,
+  TimeseriesHistoryBatchResult,
+  TimeseriesHistorySeriesInput,
+  TimeseriesPoint,
+  TimeseriesStorage,
+} from "./timeseries/types"
+export type {
+  WebhookDeliveryClaimRecord,
+  WebhookDeliveryClaimResult,
+  WebhookDeliveryKey,
+  WebhookDeliveryRecord,
+  WebhookDeliveryStatus,
+  WebhookDeliveryStorage,
+} from "./webhook-deliveries"
+export type {
+  FinishWebhookRunInput,
+  FinishWebhookRunStatus,
+  ListWebhookRunsInput,
+  ListWebhookRunsResult,
+  StartWebhookRunInput,
+  WebhookRunRecord,
+  WebhookRunStatus,
+  WebhookRunStorage,
+} from "./webhook-runs"
+export { WebhookRunError } from "./webhook-runs"
+export type {
+  CancelWorkflowInterventionInput,
+  CreateWorkflowInterventionInput,
+  ExpireWorkflowInterventionInput,
+  ListWorkflowInterventionsInput,
+  ListWorkflowInterventionsResult,
+  SubmitWorkflowInterventionInput,
+  WorkflowInterventionActor,
+  WorkflowInterventionRecord,
+  WorkflowInterventionStatus,
+  WorkflowInterventionStorage,
+} from "./workflow-interventions"
+export { WorkflowInterventionError } from "./workflow-interventions"
+export type {
+  CancelWorkflowAgentNodeRunInput,
+  ConfirmWorkflowAgentNodeRunExecutionOwnershipInput,
+  ConfirmWorkflowRunExecutionOwnershipInput,
+  CreateWorkflowAgentNodeRunInput,
+  FinishWorkflowAgentNodeRunInput,
+  FinishWorkflowNodeRunInput,
+  FinishWorkflowRunInput,
+  ListWorkflowAgentNodeRunsInput,
+  ListWorkflowAgentNodeRunsResult,
+  ListWorkflowNodeRunsInput,
+  ListWorkflowNodeRunsResult,
+  ListWorkflowRunsInput,
+  ListWorkflowRunsResult,
+  QueueWorkflowRunInput,
+  ReclaimWorkflowAgentNodeRunInput,
+  ReclaimWorkflowRunInput,
+  ResumeWorkflowRunInput,
+  StartWorkflowAgentNodeRunInput,
+  StartWorkflowNodeRunInput,
+  StartWorkflowRunInput,
+  WaitWorkflowNodeRunInput,
+  WaitWorkflowRunInput,
+  WorkflowAgentNodeRunExecution,
+  WorkflowAgentNodeRunRecord,
+  WorkflowAgentNodeRunStatus,
+  WorkflowAgentNodeRunStorage,
+  WorkflowIOSnapshot,
+  WorkflowNodeRunRecord,
+  WorkflowNodeRunStatus,
+  WorkflowNodeRunStorage,
+  WorkflowNodeRunType,
+  WorkflowRunExecution,
+  WorkflowRunRecord,
+  WorkflowRunStatus,
+  WorkflowRunStorage,
+} from "./workflow-runs"
+export { WorkflowRunError } from "./workflow-runs"
+
+export interface StorageTransactionOptions {
+  readonly isolation?: "default" | "serializable"
+}
+
+export interface Storage {
+  objects: ObjectStorage
+  timeseries: TimeseriesStorage
+  ontology: OntologyStorage
+  auth?: AuthStorage
+  agents?: AgentStorage
+  actionRuns?: ActionRunStorage
+  syncRuns?: SyncRunStorage
+  pipelineRuns?: PipelineRunStorage
+  projectionRuns?: ProjectionRunStorage
+  workflowRuns?: WorkflowRunStorage
+  workflowInterventions?: WorkflowInterventionStorage
+  webhookDeliveries?: WebhookDeliveryStorage
+  webhookRuns?: WebhookRunStorage
+  rules?: RulesStorage
+  fileUploadSessions?: FileUploadSessionStore
+
+  /** Lightweight reachability probe. It must not open a write transaction or run migrations. */
+  ping(): Promise<void>
+
+  /**
+   * Runs every capability exposed on `tx` on one atomic transaction/connection. If the callback
+   * throws, writes performed through any of those capabilities must roll back together.
+   */
+  transaction<T>(
+    run: (tx: Storage) => Promise<T> | T,
+    options?: StorageTransactionOptions
+  ): Promise<T>
+
+  /**
+   * Release external resources (connections, pools, file handles).
+   *
+   * Optional: a provider that owns none omits it. Hosts must close storage
+   * *after* whatever claims from it — the CLI drains the outbox and closes the
+   * broker first, or the final publication loses the rows it was reading.
+   */
+  close?(): void | Promise<void>
+}

package/src/storage/webhook-deliveries/in-memory.ts

@@ -0,0 +1,108 @@
+import type {
+  WebhookDeliveryClaimRecord,
+  WebhookDeliveryKey,
+  WebhookDeliveryRecord,
+  WebhookDeliveryStorage,
+} from "./types"
+
+function cloneDeliveryRecord(record: WebhookDeliveryRecord): WebhookDeliveryRecord {
+  return structuredClone(record)
+}
+
+export class InMemoryWebhookDeliveryStorage implements WebhookDeliveryStorage {
+  private readonly deliveries = new Map<string, WebhookDeliveryRecord>()
+
+  snapshot(): InMemoryWebhookDeliveryStorageSnapshot {
+    return structuredClone(this.deliveries)
+  }
+
+  restore(snapshot: InMemoryWebhookDeliveryStorageSnapshot): void {
+    this.deliveries.clear()
+    for (const [key, record] of structuredClone(snapshot)) {
+      this.deliveries.set(key, record)
+    }
+  }
+
+  async claim(
+    input: WebhookDeliveryKey & { receivedAt: string }
+  ): Promise<WebhookDeliveryClaimRecord> {
+    const key = serializeKey(input)
+    const existing = this.deliveries.get(key)
+
+    if (existing?.status === "completed") {
+      return {
+        ...cloneDeliveryRecord(existing),
+        claimResult: "duplicate",
+      }
+    }
+
+    if (existing?.status === "in_progress") {
+      return {
+        ...cloneDeliveryRecord(existing),
+        claimResult: "in_progress",
+      }
+    }
+
+    // New and failed deliveries both get a fresh handler attempt.
+    const next: WebhookDeliveryRecord = {
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      webhookId: input.webhookId,
+      idempotencyKey: input.idempotencyKey,
+      status: "in_progress",
+      receivedAt: input.receivedAt,
+    }
+    this.deliveries.set(key, structuredClone(next))
+
+    return {
+      ...cloneDeliveryRecord(next),
+      claimResult: "claimed",
+    }
+  }
+
+  async complete(
+    input: WebhookDeliveryKey & { completedAt: string }
+  ): Promise<WebhookDeliveryRecord> {
+    const key = serializeKey(input)
+    const next: WebhookDeliveryRecord = {
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      webhookId: input.webhookId,
+      idempotencyKey: input.idempotencyKey,
+      ...this.deliveries.get(key),
+      status: "completed",
+      completedAt: input.completedAt,
+      failedAt: undefined,
+      error: undefined,
+    }
+
+    this.deliveries.set(key, structuredClone(next))
+    return cloneDeliveryRecord(next)
+  }
+
+  async fail(
+    input: WebhookDeliveryKey & { failedAt: string; error: string }
+  ): Promise<WebhookDeliveryRecord> {
+    const key = serializeKey(input)
+    const next: WebhookDeliveryRecord = {
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      webhookId: input.webhookId,
+      idempotencyKey: input.idempotencyKey,
+      ...this.deliveries.get(key),
+      status: "failed",
+      failedAt: input.failedAt,
+      error: input.error,
+      completedAt: undefined,
+    }
+
+    this.deliveries.set(key, structuredClone(next))
+    return cloneDeliveryRecord(next)
+  }
+}
+
+export type InMemoryWebhookDeliveryStorageSnapshot = Map<string, WebhookDeliveryRecord>
+
+function serializeKey(key: WebhookDeliveryKey): string {
+  return JSON.stringify([key.projectId, key.connectorId, key.webhookId, key.idempotencyKey])
+}

package/src/storage/webhook-deliveries/index.ts

@@ -0,0 +1,9 @@
+export { InMemoryWebhookDeliveryStorage } from "./in-memory"
+export type {
+  WebhookDeliveryClaimRecord,
+  WebhookDeliveryClaimResult,
+  WebhookDeliveryKey,
+  WebhookDeliveryRecord,
+  WebhookDeliveryStatus,
+  WebhookDeliveryStorage,
+} from "./types"

package/src/storage/webhook-deliveries/types.ts

@@ -0,0 +1,41 @@
+export type WebhookDeliveryClaimResult = "claimed" | "duplicate" | "in_progress"
+export type WebhookDeliveryStatus = "in_progress" | "completed" | "failed"
+
+export interface WebhookDeliveryKey {
+  readonly projectId: string
+  readonly connectorId: string
+  readonly webhookId: string
+  readonly idempotencyKey: string
+}
+
+export interface WebhookDeliveryRecord extends WebhookDeliveryKey {
+  readonly status: WebhookDeliveryStatus
+  readonly receivedAt?: string
+  readonly completedAt?: string
+  readonly failedAt?: string
+  readonly error?: string
+}
+
+export interface WebhookDeliveryClaimRecord extends WebhookDeliveryRecord {
+  readonly claimResult: WebhookDeliveryClaimResult
+}
+
+/**
+ * Durable ledger used by idempotent webhooks to claim provider delivery ids.
+ *
+ * Implementations must make `claim(...)` atomic for a scoped key so duplicate
+ * provider retries cannot run the same handler concurrently.
+ */
+export interface WebhookDeliveryStorage {
+  /**
+   * Atomically reserve a provider delivery key.
+   *
+   * New or previously failed keys return "claimed". Completed keys return
+   * "duplicate", and keys currently being handled return "in_progress".
+   */
+  claim(input: WebhookDeliveryKey & { receivedAt: string }): Promise<WebhookDeliveryClaimRecord>
+  complete(input: WebhookDeliveryKey & { completedAt: string }): Promise<WebhookDeliveryRecord>
+  fail(
+    input: WebhookDeliveryKey & { failedAt: string; error: string }
+  ): Promise<WebhookDeliveryRecord>
+}

package/src/storage/webhook-runs/errors.ts

@@ -0,0 +1,6 @@
+/**
+ * Base error for webhook-run storage operations.
+ */
+export class WebhookRunError extends Error {
+  readonly name = "WebhookRunError"
+}

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

@@ -0,0 +1,131 @@
+import {
+  cloneRecord,
+  compareStartedAt,
+  hasEmptyStatuses,
+  matchesRunListDateFilters,
+  paginate,
+  storageKey,
+  toStatusSet,
+} from "../run-listing"
+import { WebhookRunError } from "./errors"
+import type {
+  FinishWebhookRunInput,
+  ListWebhookRunsInput,
+  ListWebhookRunsResult,
+  StartWebhookRunInput,
+  WebhookRunRecord,
+  WebhookRunStorage,
+} from "./types"
+
+export class InMemoryWebhookRunStorage implements WebhookRunStorage {
+  private readonly runs = new Map<string, WebhookRunRecord>()
+
+  snapshot(): InMemoryWebhookRunStorageSnapshot {
+    return structuredClone(this.runs)
+  }
+
+  restore(snapshot: InMemoryWebhookRunStorageSnapshot): void {
+    this.runs.clear()
+    for (const [key, record] of structuredClone(snapshot)) {
+      this.runs.set(key, record)
+    }
+  }
+
+  async start(input: StartWebhookRunInput): Promise<WebhookRunRecord> {
+    const key = storageKey(input.projectId, input.id)
+    if (this.runs.has(key)) {
+      throw new WebhookRunError(
+        `[Sixb] Webhook run '${input.id}' already exists for project '${input.projectId}'.`
+      )
+    }
+
+    const record: WebhookRunRecord = {
+      id: input.id,
+      projectId: input.projectId,
+      connectorId: input.connectorId,
+      webhookId: input.webhookId,
+      status: "running",
+      method: input.method,
+      route: input.route,
+      startedAt: new Date(input.startedAt ?? new Date()),
+    }
+
+    this.runs.set(key, cloneRecord(record))
+    return cloneRecord(record)
+  }
+
+  async finish(input: FinishWebhookRunInput): Promise<WebhookRunRecord> {
+    const existing = this.requireRunningWebhookRun(input.projectId, input.id)
+    const next: WebhookRunRecord = {
+      ...existing,
+      status: input.status,
+      finishedAt: new Date(input.finishedAt ?? new Date()),
+      requestBodyBytes: input.requestBodyBytes,
+      responseStatus: input.responseStatus,
+      idempotencyKey: input.idempotencyKey,
+      deliveryClaimResult: input.deliveryClaimResult,
+      error: input.status === "succeeded" ? undefined : input.error,
+    }
+
+    this.runs.set(storageKey(input.projectId, input.id), cloneRecord(next))
+    return cloneRecord(next)
+  }
+
+  async getById(params: { projectId: string; id: string }): Promise<WebhookRunRecord | null> {
+    const record = this.runs.get(storageKey(params.projectId, params.id))
+    return record ? cloneRecord(record) : null
+  }
+
+  async list(input: ListWebhookRunsInput): Promise<ListWebhookRunsResult> {
+    if (hasEmptyStatuses(input)) {
+      return {
+        runs: [],
+        hasMore: false,
+        total: 0,
+      }
+    }
+
+    const order = input.order ?? "desc"
+    const statuses = toStatusSet(input.statuses)
+    const filtered = [...this.runs.values()]
+      .filter((record) => record.projectId === input.projectId)
+      .filter((record) => (input.connectorId ? record.connectorId === input.connectorId : true))
+      .filter((record) => (input.webhookId ? record.webhookId === input.webhookId : true))
+      .filter((record) =>
+        input.idempotencyKey ? record.idempotencyKey === input.idempotencyKey : true
+      )
+      .filter((record) =>
+        matchesRunListDateFilters(record, {
+          statuses,
+          startedAfter: input.startedAfter,
+          startedBefore: input.startedBefore,
+        })
+      )
+      .sort((left, right) => compareStartedAt(left, right, order))
+
+    const { page, total, hasMore } = paginate(filtered, input)
+
+    return {
+      runs: page.map(cloneRecord),
+      hasMore,
+      total,
+    }
+  }
+
+  private requireRunningWebhookRun(projectId: string, id: string): WebhookRunRecord {
+    const record = this.runs.get(storageKey(projectId, id))
+    if (!record) {
+      throw new WebhookRunError(`[Sixb] Webhook run '${id}' not found for project '${projectId}'.`)
+    }
+
+    if (record.status !== "running") {
+      throw new WebhookRunError(
+        `[Sixb] Webhook run '${id}' for project '${projectId}' is already terminal.`
+      )
+    }
+
+    return record
+  }
+}
+
+export type InMemoryWebhookRunStorageSnapshot = Map<string, WebhookRunRecord>

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

@@ -0,0 +1,12 @@
+export { WebhookRunError } from "./errors"
+export { InMemoryWebhookRunStorage } from "./in-memory"
+export type {
+  FinishWebhookRunInput,
+  FinishWebhookRunStatus,
+  ListWebhookRunsInput,
+  ListWebhookRunsResult,
+  StartWebhookRunInput,
+  WebhookRunRecord,
+  WebhookRunStatus,
+  WebhookRunStorage,
+} from "./types"

package/src/storage/webhook-runs/types.ts

@@ -0,0 +1,69 @@
+import type { WebhookDeliveryClaimResult } from "../webhook-deliveries"
+
+export type WebhookRunStatus = "running" | "succeeded" | "failed" | "skipped"
+export type FinishWebhookRunStatus = Exclude<WebhookRunStatus, "running">
+
+export interface WebhookRunRecord {
+  readonly id: string
+  readonly projectId: string
+  readonly connectorId: string
+  readonly webhookId: string
+  readonly status: WebhookRunStatus
+  readonly method: string
+  readonly route: string
+  readonly startedAt: Date
+  readonly finishedAt?: Date
+  readonly requestBodyBytes?: number
+  readonly responseStatus?: number
+  readonly idempotencyKey?: string
+  readonly deliveryClaimResult?: WebhookDeliveryClaimResult
+  readonly error?: string
+}
+
+export interface StartWebhookRunInput {
+  readonly id: string
+  readonly projectId: string
+  readonly connectorId: string
+  readonly webhookId: string
+  readonly method: string
+  readonly route: string
+  readonly startedAt?: Date
+}
+
+export interface FinishWebhookRunInput {
+  readonly id: string
+  readonly projectId: string
+  readonly status: FinishWebhookRunStatus
+  readonly finishedAt?: Date
+  readonly requestBodyBytes?: number
+  readonly responseStatus?: number
+  readonly idempotencyKey?: string
+  readonly deliveryClaimResult?: WebhookDeliveryClaimResult
+  readonly error?: string
+}
+
+export interface ListWebhookRunsInput {
+  readonly projectId: string
+  readonly connectorId?: string
+  readonly webhookId?: string
+  readonly statuses?: readonly WebhookRunStatus[]
+  readonly idempotencyKey?: string
+  readonly startedAfter?: Date
+  readonly startedBefore?: Date
+  readonly limit?: number
+  readonly offset?: number
+  readonly order?: "asc" | "desc"
+}
+
+export interface ListWebhookRunsResult {
+  readonly runs: readonly WebhookRunRecord[]
+  readonly hasMore: boolean
+  readonly total: number
+}
+
+export interface WebhookRunStorage {
+  start(input: StartWebhookRunInput): Promise<WebhookRunRecord>
+  finish(input: FinishWebhookRunInput): Promise<WebhookRunRecord>
+  getById(params: { projectId: string; id: string }): Promise<WebhookRunRecord | null>
+  list(input: ListWebhookRunsInput): Promise<ListWebhookRunsResult>
+}

package/src/storage/workflow-interventions/errors.ts

@@ -0,0 +1,6 @@
+/**
+ * Base error for workflow-intervention storage operations.
+ */
+export class WorkflowInterventionError extends Error {
+  readonly name = "WorkflowInterventionError"
+}