@pikku/core 0.12.107 → 0.12.111

package/src/wirings/workflow/workflow-mirror.test.ts

@@ -1,171 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
-import { pikkuState } from '../../pikku-state.js'
-import type { WorkflowRunMirror } from './workflow.types.js'
-
-const MIRROR_METHODS = [
-  'createRun',
-  'updateRunStatus',
-  'insertStepState',
-  'setStepRunning',
-  'setStepScheduled',
-  'setStepResult',
-  'setStepChildRunId',
-  'setStepError',
-  'createRetryAttempt',
-  'setBranchTaken',
-  'updateRunState',
-  'upsertWorkflowVersion',
-  'updateWorkflowVersionStatus',
-] as const
-
-type Call = { method: string; args: any[] }
-
-const recordingMirror = (
-  onCall?: (method: string) => void
-): { mirror: WorkflowRunMirror; calls: Call[] } => {
-  const calls: Call[] = []
-  const mirror = {} as any
-  for (const method of MIRROR_METHODS) {
-    mirror[method] = async (...args: any[]) => {
-      calls.push({ method, args })
-      onCall?.(method)
-    }
-  }
-  return { mirror, calls }
-}
-
-const service = (mirror?: WorkflowRunMirror) => {
-  pikkuState(null, 'package', 'singletonServices', {
-    logger: { error() {}, info() {}, warn() {}, debug() {} },
-  } as any)
-  const ws = new InMemoryWorkflowService() as any
-  ws.mirror = mirror
-  return ws
-}
-
-const driveEveryWrite = async (ws: any) => {
-  const runId = await ws.createRun('flow', { a: 1 }, false, 'hash', {
-    type: 'test',
-  })
-  const step = await ws.insertStepState(runId, 'step-1', 'rpc.fn', { x: 1 })
-  await ws.setStepRunning(step.stepId)
-  await ws.setStepScheduled(step.stepId)
-  await ws.setStepResult(step.stepId, 'ok')
-  await ws.setStepChildRunId(step.stepId, 'child-1')
-  await ws.setStepError(step.stepId, new Error('boom'))
-  await ws.createRetryAttempt(step.stepId, 'pending')
-  await ws.setBranchTaken(step.stepId, 'left')
-  await ws.updateRunState(runId, 'total', 42)
-  await ws.upsertWorkflowVersion('flow', 'hash', { nodes: {} }, 'code')
-  await ws.updateWorkflowVersionStatus('flow', 'hash', 'archived')
-  await ws.updateRunStatus(runId, 'completed', 'output')
-  return { runId, step }
-}
-
-describe('mirroring workflow state', () => {
-  test('every mirror method is wired to the write it shadows', async () => {
-    const { mirror, calls } = recordingMirror()
-    await driveEveryWrite(service(mirror))
-
-    assert.deepEqual(
-      [...new Set(calls.map((c) => c.method))].sort(),
-      [...MIRROR_METHODS].sort()
-    )
-  })
-
-  test('a mirror write carries the same identifiers as the write it shadows', async () => {
-    const { mirror, calls } = recordingMirror()
-    const ws = service(mirror)
-    const { runId, step } = await driveEveryWrite(ws)
-
-    const call = (method: string) => calls.find((c) => c.method === method)!
-    assert.equal(call('createRun').args[0], runId)
-    assert.equal(call('createRun').args[1], 'flow')
-    assert.equal(call('insertStepState').args[0], runId)
-    assert.equal(call('insertStepState').args[1].stepId, step.stepId)
-    assert.equal(call('insertStepState').args[1].stepName, 'step-1')
-    assert.equal(call('insertStepState').args[1].rpcName, 'rpc.fn')
-    assert.equal(call('setStepResult').args[1], 'ok')
-    assert.equal(call('setStepChildRunId').args[1], 'child-1')
-    assert.equal(call('setBranchTaken').args[1], 'left')
-    assert.equal(call('updateRunState').args[2], 42)
-    assert.equal(call('updateRunStatus').args[1], 'completed')
-  })
-
-  test('a step error reaches the mirror serialised, not as a live Error', async () => {
-    const { mirror, calls } = recordingMirror()
-    await driveEveryWrite(service(mirror))
-
-    const serialised = calls.find((c) => c.method === 'setStepError')!.args[1]
-    assert.equal(serialised instanceof Error, false)
-    assert.equal(serialised.message, 'boom')
-    assert.equal(typeof serialised.stack, 'string')
-    assert.equal(typeof serialised.expected, 'boolean')
-  })
-
-  test('the mirror only ever sees a write that already landed', async () => {
-    const seen: Array<string | undefined> = []
-    const { mirror } = recordingMirror()
-    const ws = service(mirror)
-    ;(mirror as any).updateRunStatus = async () => {
-      seen.push((await ws.getRun(runIdRef.id))?.status)
-    }
-    const runIdRef = { id: '' }
-
-    runIdRef.id = await ws.createRun('flow', {}, false, 'hash', {
-      type: 'test',
-    })
-    await ws.updateRunStatus(runIdRef.id, 'completed', 'output')
-
-    assert.deepEqual(
-      seen,
-      ['completed'],
-      'the mirror ran before the write it was mirroring'
-    )
-  })
-
-  test('a write that fails is not mirrored', async () => {
-    const { mirror, calls } = recordingMirror()
-    const ws = service(mirror)
-    ws.updateRunStatusImpl = async () => {
-      throw new Error('database down')
-    }
-    const runId = await ws.createRun('flow', {}, false, 'hash', {
-      type: 'test',
-    })
-
-    await assert.rejects(
-      ws.updateRunStatus(runId, 'completed'),
-      /database down/
-    )
-    assert.equal(
-      calls.some((c) => c.method === 'updateRunStatus'),
-      false,
-      'a status the store rejected was reported to the mirror as if it had happened'
-    )
-  })
-})
-
-describe('a mirror that is broken', () => {
-  test('no write fails because the mirror did', async () => {
-    const { mirror } = recordingMirror((method) => {
-      throw new Error(`mirror down on ${method}`)
-    })
-    const ws = service(mirror)
-
-    const { runId } = await driveEveryWrite(ws)
-
-    assert.equal((await ws.getRun(runId))?.status, 'completed')
-    assert.equal((await ws.getRun(runId))?.output, 'output')
-    assert.deepEqual(await ws.getRunState(runId), { total: 42 })
-  })
-
-  test('no mirror configured is not an error path', async () => {
-    const ws = service(undefined)
-    const { runId } = await driveEveryWrite(ws)
-    assert.equal((await ws.getRun(runId))?.status, 'completed')
-  })
-})

package/src/wirings/workflow/workflow-missing-meta.test.ts

@@ -1,92 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import { PikkuMissingMetaError } from '../../errors/errors.js'
-import { WorkflowNotFoundError } from './workflow-errors.js'
-
-const silentLogger = { error() {}, info() {}, warn() {}, debug() {} }
-
-const startRun = async (workflowName: string) => {
-  pikkuState(null, 'package', 'singletonServices', {
-    logger: silentLogger,
-  } as any)
-  const service = new InMemoryWorkflowService()
-  const runId = await service.createRun(workflowName, {}, false, '', {
-    type: 'test',
-  })
-  return { service, runId }
-}
-
-describe('a run whose workflow has no generated meta', () => {
-  test('reports missing metadata rather than crashing on an undefined meta', async () => {
-    resetPikkuState()
-    const { service, runId } = await startRun('flowWithoutMeta')
-
-    // The registration exists, so this is not an unknown workflow — codegen or
-    // the generated bootstrap import is what is missing.
-    pikkuState(null, 'workflows', 'registrations').set('flowWithoutMeta', {
-      name: 'flowWithoutMeta',
-      func: async () => undefined,
-    } as any)
-
-    await assert.rejects(
-      service.runWorkflowJob(runId, {}),
-      (error: unknown) => {
-        assert.ok(
-          error instanceof PikkuMissingMetaError,
-          `expected PikkuMissingMetaError, got ${(error as Error)?.constructor?.name}: ${(error as Error)?.message}`
-        )
-        assert.match(String((error as Error).message), /flowWithoutMeta/)
-        return true
-      }
-    )
-  })
-
-  test('a workflow with neither meta nor a registration is still missing meta', async () => {
-    resetPikkuState()
-    const { service, runId } = await startRun('unknownFlow')
-
-    await assert.rejects(
-      service.runWorkflowJob(runId, {}),
-      (error: unknown) => {
-        assert.ok(
-          error instanceof PikkuMissingMetaError,
-          `expected PikkuMissingMetaError, got ${(error as Error)?.constructor?.name}`
-        )
-        return true
-      }
-    )
-  })
-
-  test('a registered workflow that does have meta gets past both guards', async () => {
-    resetPikkuState()
-    const { service, runId } = await startRun('flowWithMeta')
-
-    pikkuState(null, 'workflows', 'meta', {
-      flowWithMeta: {
-        name: 'flowWithMeta',
-        pikkuFuncId: 'flowWithMeta',
-        source: 'dsl',
-      },
-    } as any)
-
-    // Guards the tests above: without this the assertions would pass for a
-    // service that threw PikkuMissingMetaError unconditionally.
-    await assert.rejects(
-      service.runWorkflowJob(runId, {}),
-      (error: unknown) => {
-        assert.ok(
-          !(error instanceof PikkuMissingMetaError),
-          'meta was present, so the missing-meta guard must not fire'
-        )
-        assert.ok(
-          error instanceof WorkflowNotFoundError,
-          `expected WorkflowNotFoundError, got ${(error as Error)?.constructor?.name}`
-        )
-        return true
-      }
-    )
-  })
-})

package/src/wirings/workflow/workflow-on-error.test.ts

@@ -1,145 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
-
-class TestWorkflowService extends InMemoryWorkflowService {
-  public compensations: Array<{ rpcName: string; data: any }> = []
-  public dispatches = 0
-  private pretendDispatchSucceeds = false
-
-  public alwaysDispatch() {
-    this.pretendDispatchSucceeds = true
-  }
-
-  protected override async dispatchStep(...args: any[]): Promise<boolean> {
-    this.dispatches++
-    if (this.pretendDispatchSucceeds) {
-      return true
-    }
-    return (super.dispatchStep as any)(...args)
-  }
-
-  public async callFailedStep(
-    runId: string,
-    stepName: string,
-    onError?: string
-  ) {
-    const self = this as any
-    const realRpcStep = self.rpcStep.bind(self)
-    let depth = 0
-    self.rpcStep = async (...args: any[]) => {
-      if (depth++ > 0) {
-        this.compensations.push({ rpcName: args[2], data: args[3] })
-        return { compensated: true }
-      }
-      return realRpcStep(...args)
-    }
-    return self.rpcStep(runId, stepName, 'chargeCard', {}, {}, { onError })
-  }
-}
-
-async function seedPendingStep(ws: TestWorkflowService, stepName: string) {
-  const runId = await ws.createRun('wf', {}, true, 'hash', {
-    type: 'inline',
-  } as any)
-  const step = await ws.insertStepState(runId, stepName, 'chargeCard', {})
-  return { runId, step }
-}
-
-async function seedFailedStep(ws: TestWorkflowService, stepName: string) {
-  const runId = await ws.createRun('wf', {}, true, 'hash', {
-    type: 'inline',
-  } as any)
-  const step = await ws.insertStepState(runId, stepName, 'chargeCard', {})
-  await (ws as any).updateStepStateImpl?.(runId, stepName, {
-    status: 'failed',
-    error: { message: 'card declined' },
-  })
-  const raw = (ws as any).steps ?? (ws as any).stepStates
-  if (raw?.get) {
-    const key = [...raw.keys()].find((k: string) => k.includes(stepName))
-    if (key) {
-      raw.set(key, {
-        ...raw.get(key),
-        status: 'failed',
-        error: { message: 'card declined' },
-      })
-    }
-  }
-  return { runId, step }
-}
-
-describe('workflow onError — compensation on terminal step failure', () => {
-  test('a failed step runs its handler and still throws the original error', async () => {
-    const ws = new TestWorkflowService()
-    const { runId } = await seedFailedStep(ws, 'Charge')
-
-    await assert.rejects(
-      () => ws.callFailedStep(runId, 'Charge', 'refundOrder'),
-      /card declined/,
-      'compensation must not swallow the failure — the workflow still fails'
-    )
-
-    assert.equal(
-      ws.compensations.length,
-      1,
-      'the onError handler must have been invoked'
-    )
-    assert.equal(ws.compensations[0].rpcName, 'refundOrder')
-    assert.deepEqual(
-      ws.compensations[0].data,
-      { error: { message: 'card declined' } },
-      'the handler receives the failure reason, as a graph onError node does'
-    )
-  })
-
-  test('a step still sitting on the queue pauses without compensating', async () => {
-    const ws = new TestWorkflowService()
-    const { runId, step } = await seedPendingStep(ws, 'Charge')
-    await ws.setStepScheduled(step.stepId)
-
-    await assert.rejects(
-      () => ws.callFailedStep(runId, 'Charge', 'refundOrder'),
-      (error: Error) => error.name === 'WorkflowAsyncException',
-      'a scheduled step must pause the workflow, not fail it'
-    )
-
-    assert.equal(
-      ws.compensations.length,
-      0,
-      'compensating a step that has not run yet would refund a charge that was never made'
-    )
-  })
-
-  test('the pause thrown right after dispatch does not compensate', async () => {
-    const ws = new TestWorkflowService()
-    ws.alwaysDispatch()
-    const { runId } = await seedPendingStep(ws, 'Charge')
-
-    await assert.rejects(
-      () => ws.callFailedStep(runId, 'Charge', 'refundOrder'),
-      (error: Error) => error.name === 'WorkflowAsyncException',
-      'a freshly dispatched step pauses the workflow'
-    )
-
-    assert.equal(ws.dispatches, 1, 'the step should have been dispatched once')
-    assert.equal(
-      ws.compensations.length,
-      0,
-      'queued is not failed — the handler must not run'
-    )
-  })
-
-  test('a failed step with no onError simply throws', async () => {
-    const ws = new TestWorkflowService()
-    const { runId } = await seedFailedStep(ws, 'Charge')
-
-    await assert.rejects(() => ws.callFailedStep(runId, 'Charge', undefined))
-    assert.equal(
-      ws.compensations.length,
-      0,
-      'no handler configured means nothing to compensate'
-    )
-  })
-})

package/src/wirings/workflow/workflow-queue-routing.ts

@@ -1,129 +0,0 @@
-import { getSingletonServices, pikkuState } from '../../pikku-state.js'
-import { getDurationInMilliseconds } from '../../time-utils.js'
-import type { JobGroup, JobOptions } from '../queue/queue.types.js'
-import type {
-  WorkflowServiceConfig,
-  WorkflowStepOptions,
-} from './workflow.types.js'
-import { DEFAULT_STEP_RETRIES } from './workflow-constants.js'
-
-export type WorkflowQueueStrategy = 'per-workflow' | 'shared-groups'
-
-const toKebab = (s: string) =>
-  s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
-
-export const resolveWorkflowConfig = (): WorkflowServiceConfig => {
-  const workflow = getSingletonServices().config?.workflow
-  return {
-    retries: workflow?.retries ?? DEFAULT_STEP_RETRIES,
-    retryDelay: workflow?.retryDelay ?? 0,
-    orchestratorQueueName:
-      workflow?.orchestratorQueueName ?? 'pikku-workflow-orchestrator',
-    stepWorkerQueueName:
-      workflow?.stepWorkerQueueName ?? 'pikku-workflow-step-worker',
-    sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
-  }
-}
-
-/**
- * Falls back to the shared queue whenever the dedicated one was not generated
- * into queue meta, so a workflow added without a rebuild still runs.
- */
-const dedicatedQueueName = (
-  prefix: string,
-  name: string | undefined,
-  strategy: WorkflowQueueStrategy,
-  fallback: string
-): string => {
-  if (!name || strategy === 'shared-groups') {
-    return fallback
-  }
-  const dedicated = `${prefix}${toKebab(name)}`
-  return pikkuState(null, 'queue', 'meta')[dedicated] ? dedicated : fallback
-}
-
-export const orchestratorQueueName = (
-  strategy: WorkflowQueueStrategy,
-  workflowName?: string
-): string =>
-  dedicatedQueueName(
-    'wf-orchestrator-',
-    workflowName,
-    strategy,
-    resolveWorkflowConfig().orchestratorQueueName
-  )
-
-export const stepWorkerQueueName = (
-  strategy: WorkflowQueueStrategy,
-  rpcName?: string
-): string =>
-  dedicatedQueueName(
-    'wf-step-',
-    rpcName,
-    strategy,
-    resolveWorkflowConfig().stepWorkerQueueName
-  )
-
-/**
- * How a step reaches its worker: on the queue, or here in the orchestrator.
- *
- * A step naming a workflow queues whenever a queue exists, even unmarked. Run
- * here, it holds the parent's run lock — and its lock connection — until the
- * child ends, and marks the child inline so the child's own `sleep` degrades
- * from a suspension into a real in-process wait. Workflows cannot opt in
- * through `workflowQueued`: that flag is read off `rpc` meta, and `addWorkflow`
- * never registers there.
- *
- * Throws only for a step that asked for the queue by name and has none, which
- * is a deployment missing a service rather than a routing choice.
- *
- * `parentIsInline` is a thunk because resolving it can read the run store, and
- * every step dispatch would pay for that — only a step that names a workflow
- * and has a queue to reach ever asks.
- */
-export const stepDispatchTarget = async (
-  rpcName: string,
-  stepName: string,
-  parentIsInline: () => Promise<boolean>
-): Promise<'queue' | 'inline'> => {
-  const rpcFuncId = pikkuState(null, 'rpc', 'meta')[rpcName]
-  const rpcMeta =
-    typeof rpcFuncId === 'string'
-      ? pikkuState(null, 'function', 'meta')[rpcFuncId]
-      : undefined
-  const hasQueue = getSingletonServices()?.queueService !== undefined
-  if (rpcMeta?.workflowQueued === true) {
-    if (!hasQueue) {
-      throw new Error(
-        `Workflow step '${stepName}' (function '${rpcName}') is marked 'workflowQueued: true' but no queue service is configured.`
-      )
-    }
-    return 'queue'
-  }
-  const isWorkflow =
-    pikkuState(null, 'workflows', 'meta')[rpcName] !== undefined
-  if (!isWorkflow || !hasQueue) {
-    return 'inline'
-  }
-  return (await parentIsInline()) ? 'inline' : 'queue'
-}
-
-export const jobGroupFor = (
-  strategy: WorkflowQueueStrategy,
-  id?: string
-): JobGroup | undefined =>
-  id && strategy === 'shared-groups' ? { id, tier: id } : undefined
-
-export const stepJobOptions = (
-  stepOptions?: WorkflowStepOptions
-): JobOptions => {
-  const retries = stepOptions?.retries ?? DEFAULT_STEP_RETRIES
-  const retryDelay = stepOptions?.retryDelay
-  const backoff =
-    retryDelay !== undefined && retryDelay !== 'exponential'
-      ? { type: 'fixed', delay: getDurationInMilliseconds(retryDelay) }
-      : retries > 0 || retryDelay === 'exponential'
-        ? 'exponential'
-        : undefined
-  return { attempts: retries + 1, ...(backoff ? { backoff } : {}) }
-}

package/src/wirings/workflow/workflow-queue-wiring.ts

@@ -1,149 +0,0 @@
-import { addFunction } from '../../function/function-runner.js'
-import { pikkuState } from '../../pikku-state.js'
-import { wireQueueWorker } from '../queue/queue-runner.js'
-import type {
-  GroupConcurrencyConfig,
-  PikkuWorkerConfig,
-} from '../queue/queue.types.js'
-import type { Logger } from '../../services/logger.js'
-import {
-  pikkuWorkflowOrchestratorFunc,
-  pikkuWorkflowSleeperFunc,
-  pikkuWorkflowWorkerFunc,
-} from './workflow-queue-workers.js'
-import type { WorkflowQueueStrategy } from './workflow-queue-routing.js'
-
-const ORCHESTRATOR_QUEUE_PREFIX = 'wf-orchestrator-'
-const STEP_QUEUE_PREFIX = 'wf-step-'
-
-const helperFunctionMeta = (funcId: string) => ({
-  pikkuFuncId: funcId,
-  sessionless: true,
-  functionType: 'helper' as const,
-  inputSchemaName: null,
-  outputSchemaName: null,
-})
-
-export type WorkflowQueueWiringOptions = {
-  strategy: WorkflowQueueStrategy
-  concurrency: number
-  groupConcurrency: number | GroupConcurrencyConfig
-  /**
-   * Resolved only when there is something to warn about: reading the logger
-   * throws while singleton services are uninitialized, and wiring queues before
-   * that point is legitimate.
-   */
-  getLogger: () => Logger | undefined
-}
-
-/**
- * Registers the orchestrator, step-worker and sleeper functions and binds them
- * to their queues. Idempotent: a queue already carrying a registered function
- * is left alone.
- */
-export const wireWorkflowQueueWorkers = ({
-  strategy,
-  concurrency,
-  groupConcurrency,
-  getLogger,
-}: WorkflowQueueWiringOptions): void => {
-  const functions = pikkuState(null, 'function', 'functions')
-  const functionsMeta = pikkuState(null, 'function', 'meta')
-  const queueMeta = pikkuState(null, 'queue', 'meta')
-
-  const registerWorkflowFunc = (
-    funcId: string,
-    func: { func: unknown },
-    queueName: string,
-    config?: PikkuWorkerConfig
-  ) => {
-    if (functions.has(funcId)) return
-    addFunction(funcId, func as never)
-    if (!queueMeta[queueName]) {
-      queueMeta[queueName] = { pikkuFuncId: funcId, name: queueName }
-    }
-    wireQueueWorker({ name: queueName, func, config } as never)
-    if (!functionsMeta[funcId]) {
-      functionsMeta[funcId] = helperFunctionMeta(funcId)
-    }
-  }
-
-  const sharedGroups = strategy === 'shared-groups'
-  const sharedQueueConfig: PikkuWorkerConfig | undefined = sharedGroups
-    ? { batchSize: concurrency, groupConcurrency }
-    : undefined
-
-  registerWorkflowFunc(
-    'pikkuWorkflowOrchestrator',
-    { func: pikkuWorkflowOrchestratorFunc },
-    'pikku-workflow-orchestrator',
-    sharedQueueConfig
-  )
-  registerWorkflowFunc(
-    'pikkuWorkflowStepWorker',
-    { func: pikkuWorkflowWorkerFunc },
-    'pikku-workflow-step-worker',
-    sharedQueueConfig
-  )
-
-  const registerDedicatedQueues = (meta: Record<string, any>) => {
-    for (const [queueName, entry] of Object.entries(meta)) {
-      if (functions.has(entry.pikkuFuncId)) continue
-      if (queueName.startsWith(ORCHESTRATOR_QUEUE_PREFIX)) {
-        registerWorkflowFunc(
-          entry.pikkuFuncId,
-          { func: pikkuWorkflowOrchestratorFunc },
-          queueName
-        )
-      } else if (queueName.startsWith(STEP_QUEUE_PREFIX)) {
-        registerWorkflowFunc(
-          entry.pikkuFuncId,
-          { func: pikkuWorkflowWorkerFunc },
-          queueName
-        )
-      }
-    }
-  }
-
-  if (!sharedGroups) {
-    registerDedicatedQueues(pikkuState(null, 'queue', 'meta'))
-
-    const addons = pikkuState(null, 'addons', 'packages')
-    for (const [, addon] of addons ?? []) {
-      const addonQueueMeta = pikkuState(addon.package, 'queue', 'meta')
-      if (addonQueueMeta) {
-        registerDedicatedQueues(addonQueueMeta)
-      }
-    }
-  }
-
-  warnOnMissingDedicatedQueues(queueMeta, getLogger)
-
-  if (!functions.has('pikkuWorkflowSleeper')) {
-    addFunction('pikkuWorkflowSleeper', { func: pikkuWorkflowSleeperFunc })
-  }
-  if (!functionsMeta.pikkuWorkflowSleeper) {
-    functionsMeta.pikkuWorkflowSleeper = helperFunctionMeta(
-      'pikkuWorkflowSleeper'
-    )
-  }
-}
-
-const warnOnMissingDedicatedQueues = (
-  queueMeta: Record<string, unknown>,
-  getLogger: () => Logger | undefined
-) => {
-  const workflowCount = Object.keys(
-    pikkuState(null, 'workflows', 'meta') ?? {}
-  ).length
-  const dedicatedQueues = Object.keys(queueMeta).filter((name) =>
-    name.startsWith(ORCHESTRATOR_QUEUE_PREFIX)
-  ).length
-  if (workflowCount > 0 && dedicatedQueues === 0) {
-    getLogger()?.warn?.(
-      `[pikku] ${workflowCount} workflow(s) registered but no per-workflow orchestrator queues were found in queue meta. ` +
-        `All workflows will share a single orchestrator queue, where one slow step blocks every other workflow behind it. ` +
-        `Check that the generated bootstrap imports the queue-workers meta (pikku-queue-workers-wirings-meta.gen.js).`
-    )
-  }
-}