@pikku/core 0.12.0 → 0.12.1

package/src/services/local-variables.test.ts

@@ -0,0 +1,61 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { LocalVariablesService } from './local-variables.js'
+
+describe('LocalVariablesService', () => {
+  test('should get a variable', () => {
+    const service = new LocalVariablesService({ MY_VAR: 'hello' })
+    assert.strictEqual(service.get('MY_VAR'), 'hello')
+  })
+
+  test('should return undefined for missing variable', () => {
+    const service = new LocalVariablesService({})
+    assert.strictEqual(service.get('MISSING'), undefined)
+  })
+
+  test('should set a variable', () => {
+    const service = new LocalVariablesService({})
+    service.set('KEY', 'value')
+    assert.strictEqual(service.get('KEY'), 'value')
+  })
+
+  test('should delete a variable', () => {
+    const service = new LocalVariablesService({ KEY: 'val' })
+    service.delete('KEY')
+    assert.strictEqual(service.get('KEY'), undefined)
+  })
+
+  test('should check if variable exists', () => {
+    const service = new LocalVariablesService({ KEY: 'val' })
+    assert.strictEqual(service.has('KEY'), true)
+    assert.strictEqual(service.has('MISSING'), false)
+  })
+
+  test('should get all variables', () => {
+    const vars = { A: '1', B: '2' }
+    const service = new LocalVariablesService(vars)
+    assert.deepStrictEqual(service.getAll(), vars)
+  })
+
+  test('should get JSON variable', () => {
+    const service = new LocalVariablesService({ DATA: '{"key":"val"}' })
+    const result = service.getJSON('DATA')
+    assert.deepStrictEqual(result, { key: 'val' })
+  })
+
+  test('should return undefined for missing JSON variable', () => {
+    const service = new LocalVariablesService({})
+    assert.strictEqual(service.getJSON('MISSING'), undefined)
+  })
+
+  test('should set JSON variable', () => {
+    const service = new LocalVariablesService({})
+    service.setJSON('DATA', { key: 'val' })
+    assert.strictEqual(service.get('DATA'), '{"key":"val"}')
+  })
+
+  test('should handle has with undefined value', () => {
+    const service = new LocalVariablesService({ KEY: undefined })
+    assert.strictEqual(service.has('KEY'), false)
+  })
+})

package/src/services/local-variables.ts

@@ -1,4 +1,4 @@
-import { VariablesService } from './variables-service.js'
+import type { VariablesService } from './variables-service.js'
 
 export class LocalVariablesService implements VariablesService {
   constructor(

package/src/services/logger-console.test.ts

@@ -0,0 +1,118 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert'
+import { ConsoleLogger } from './logger-console.js'
+import { LogLevel } from './logger.js'
+
+describe('ConsoleLogger', () => {
+  let logger: ConsoleLogger
+  let captured: { method: string; args: any[] }[]
+  let origConsole: Record<string, any>
+
+  beforeEach(() => {
+    logger = new ConsoleLogger()
+    captured = []
+    origConsole = {
+      trace: console.trace,
+      debug: console.debug,
+      info: console.info,
+      warn: console.warn,
+      error: console.error,
+      log: console.log,
+    }
+    console.trace = (...args: any[]) => captured.push({ method: 'trace', args })
+    console.debug = (...args: any[]) => captured.push({ method: 'debug', args })
+    console.info = (...args: any[]) => captured.push({ method: 'info', args })
+    console.warn = (...args: any[]) => captured.push({ method: 'warn', args })
+    console.error = (...args: any[]) => captured.push({ method: 'error', args })
+    console.log = (...args: any[]) => captured.push({ method: 'log', args })
+  })
+
+  // Restore console after each test
+  test('should log info at default level', () => {
+    logger.info('test message')
+    assert.strictEqual(captured.length, 1)
+    assert.strictEqual(captured[0].method, 'info')
+    assert.ok(captured[0].args.includes('test message'))
+    Object.assign(console, origConsole)
+  })
+
+  test('should not log debug at default info level', () => {
+    logger.debug('debug message')
+    assert.strictEqual(captured.length, 0)
+    Object.assign(console, origConsole)
+  })
+
+  test('should log debug when level is set to debug', () => {
+    logger.setLevel(LogLevel.debug)
+    logger.debug('debug message')
+    assert.strictEqual(captured.length, 1)
+    assert.strictEqual(captured[0].method, 'debug')
+    Object.assign(console, origConsole)
+  })
+
+  test('should log warn at info level', () => {
+    logger.warn('warning')
+    assert.strictEqual(captured.length, 1)
+    assert.strictEqual(captured[0].method, 'warn')
+    Object.assign(console, origConsole)
+  })
+
+  test('should log error at info level', () => {
+    logger.error('error message')
+    assert.strictEqual(captured.length, 1)
+    assert.strictEqual(captured[0].method, 'error')
+    Object.assign(console, origConsole)
+  })
+
+  test('should log Error instance with stack trace', () => {
+    const err = new Error('test error')
+    logger.error(err)
+    assert.strictEqual(captured.length, 2) // error message + stack
+    assert.ok(captured[0].args.includes('test error'))
+    assert.strictEqual(captured[1].args[0], 'STACK:')
+    Object.assign(console, origConsole)
+  })
+
+  test('should not log info when level is error', () => {
+    logger.setLevel(LogLevel.error)
+    logger.info('info')
+    logger.warn('warn')
+    logger.debug('debug')
+    assert.strictEqual(captured.length, 0)
+    Object.assign(console, origConsole)
+  })
+
+  test('should log error when level is error', () => {
+    logger.setLevel(LogLevel.error)
+    logger.error('critical')
+    assert.strictEqual(captured.length, 1)
+    Object.assign(console, origConsole)
+  })
+
+  test('should support trace level when enabled', () => {
+    logger.setLevel(LogLevel.trace)
+    logger.trace!('trace message')
+    assert.strictEqual(captured.length, 1)
+    assert.strictEqual(captured[0].method, 'trace')
+    Object.assign(console, origConsole)
+  })
+
+  test('should log with additional metadata', () => {
+    logger.info('message', { extra: 'data' })
+    assert.ok(captured[0].args.includes('message'))
+    Object.assign(console, origConsole)
+  })
+
+  test('should handle object messages in info', () => {
+    logger.info({ key: 'value' })
+    assert.strictEqual(captured.length, 1)
+    Object.assign(console, origConsole)
+  })
+
+  test('log method should respect level', () => {
+    logger.setLevel(LogLevel.error)
+    logger.log('info', 'should not show')
+    assert.strictEqual(captured.length, 0)
+    Object.assign(console, origConsole)
+  })
+})

package/src/services/logger-console.ts

@@ -1,4 +1,5 @@
-import { Logger, LogLevel } from './logger.js'
+import type { Logger } from './logger.js'
+import { LogLevel } from './logger.js'
 
 /**
  * A logger implementation that logs messages to the console.

package/src/services/scheduler-service.ts

@@ -1,5 +1,4 @@
 import type { CoreUserSession } from '../types/core.types.js'
-import type { Logger } from './logger.js'
 
 /**
  * Minimal metadata for listing scheduled tasks
@@ -25,16 +24,6 @@ export interface ScheduledTaskInfo extends ScheduledTaskSummary {
   status?: 'scheduled' | 'active' | 'completed' | 'failed'
 }
 
-export interface SchedulerRuntimeHandlers {
-  logger: Logger
-  invokeRPC: (
-    rpcName: string,
-    data?: any,
-    session?: CoreUserSession
-  ) => Promise<void>
-  runScheduledTask: (name: string) => Promise<void>
-}
-
 /**
  * Abstract scheduler service for persistent scheduled task management
  * Implementations use queue backends (pg-boss, BullMQ) for distributed scheduling
@@ -85,13 +74,6 @@ export abstract class SchedulerService {
    */
   abstract close(): Promise<void>
 
-  /**
-   * Set services needed for processing recurring tasks.
-   * Called after construction since the scheduler is created before
-   * singletonServices are fully assembled.
-   */
-  setServices(_handlers: SchedulerRuntimeHandlers): void {}
-
   /**
    * Start recurring scheduled tasks
    */

package/src/services/scoped-secret-service.test.ts

@@ -0,0 +1,74 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { ScopedSecretService } from './scoped-secret-service.js'
+
+const createMockSecrets = () => ({
+  getSecret: async (key: string) => `value-of-${key}`,
+  getSecretJSON: async (key: string) => ({ key }),
+  hasSecret: async () => true,
+  setSecretJSON: async () => {},
+  deleteSecret: async () => {},
+})
+
+describe('ScopedSecretService', () => {
+  test('should allow access to allowed keys', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1', 'KEY2']))
+    const result = await scoped.getSecret('KEY1')
+    assert.strictEqual(result, 'value-of-KEY1')
+  })
+
+  test('should deny access to non-allowed keys', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    await assert.rejects(() => scoped.getSecret('KEY2'), {
+      message: 'Access denied to secret key: KEY2',
+    })
+  })
+
+  test('should allow getSecretJSON for allowed keys', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    const result = await scoped.getSecretJSON('KEY1')
+    assert.deepStrictEqual(result, { key: 'KEY1' })
+  })
+
+  test('should deny getSecretJSON for non-allowed keys', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    await assert.rejects(() => scoped.getSecretJSON('FORBIDDEN'), {
+      message: 'Access denied to secret key: FORBIDDEN',
+    })
+  })
+
+  test('should allow hasSecret for allowed keys', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    const result = await scoped.hasSecret('KEY1')
+    assert.strictEqual(result, true)
+  })
+
+  test('should deny hasSecret for non-allowed keys', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    await assert.rejects(() => scoped.hasSecret('KEY2'), {
+      message: 'Access denied to secret key: KEY2',
+    })
+  })
+
+  test('should always throw on setSecretJSON', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    await assert.rejects(() => scoped.setSecretJSON('KEY1', 'val'), {
+      message: 'setSecretJSON is not allowed in scoped secret service',
+    })
+  })
+
+  test('should always throw on deleteSecret', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    await assert.rejects(() => scoped.deleteSecret('KEY1'), {
+      message: 'deleteSecret is not allowed in scoped secret service',
+    })
+  })
+})

package/src/services/scoped-secret-service.ts

@@ -1,4 +1,4 @@
-import { SecretService } from './secret-service.js'
+import type { SecretService } from './secret-service.js'
 
 /**
  * A read-only wrapper around SecretService that restricts access

package/src/services/trigger-service.ts

@@ -1,10 +1,3 @@
-import {
-  CoreSingletonServices,
-  CreateWireServices,
-  CoreServices,
-  CoreUserSession,
-} from '../types/core.types.js'
-
 /**
  * Abstract TriggerService interface.
  *
@@ -12,20 +5,6 @@ import {
  * and dispatching to RPC targets or workflow starts.
  */
 export interface TriggerService {
-  /**
-   * Set services needed for processing triggers.
-   * Called after construction since the trigger service is created before
-   * singletonServices are fully assembled.
-   */
-  setServices(
-    _singletonServices: CoreSingletonServices,
-    _createWireServices?: CreateWireServices<
-      CoreSingletonServices,
-      CoreServices,
-      CoreUserSession
-    >
-  ): void
-
   /**
    * Start all triggers
    */

package/src/services/typed-secret-service.test.ts

@@ -0,0 +1,93 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { TypedSecretService } from './typed-secret-service.js'
+
+const createMockSecrets = (store: Map<string, string> = new Map()) => ({
+  getSecret: async (key: string) => {
+    const val = store.get(key)
+    if (!val) throw new Error(`Not found: ${key}`)
+    return val
+  },
+  getSecretJSON: async (key: string) => {
+    const val = store.get(key)
+    if (!val) throw new Error(`Not found: ${key}`)
+    return JSON.parse(val)
+  },
+  hasSecret: async (key: string) => store.has(key),
+  setSecretJSON: async (key: string, value: unknown) => {
+    store.set(key, JSON.stringify(value))
+  },
+  deleteSecret: async (key: string) => {
+    store.delete(key)
+  },
+})
+
+describe('TypedSecretService', () => {
+  test('should delegate getSecret to underlying service', async () => {
+    const store = new Map([['API_KEY', 'sk-123']])
+    const service = new TypedSecretService(createMockSecrets(store), {})
+    const result = await service.getSecret('API_KEY')
+    assert.strictEqual(result, 'sk-123')
+  })
+
+  test('should delegate getSecretJSON to underlying service', async () => {
+    const store = new Map([['CONFIG', '{"port":3000}']])
+    const service = new TypedSecretService(createMockSecrets(store), {})
+    const result = await service.getSecretJSON('CONFIG')
+    assert.deepStrictEqual(result, { port: 3000 })
+  })
+
+  test('should delegate hasSecret to underlying service', async () => {
+    const store = new Map([['EXISTS', 'val']])
+    const service = new TypedSecretService(createMockSecrets(store), {})
+    assert.strictEqual(await service.hasSecret('EXISTS'), true)
+    assert.strictEqual(await service.hasSecret('MISSING'), false)
+  })
+
+  test('should delegate setSecretJSON to underlying service', async () => {
+    const store = new Map<string, string>()
+    const service = new TypedSecretService(createMockSecrets(store), {})
+    await service.setSecretJSON('NEW_KEY', { data: 'val' })
+    assert.strictEqual(store.get('NEW_KEY'), '{"data":"val"}')
+  })
+
+  test('should delegate deleteSecret to underlying service', async () => {
+    const store = new Map([['KEY', 'val']])
+    const service = new TypedSecretService(createMockSecrets(store), {})
+    await service.deleteSecret('KEY')
+    assert.strictEqual(store.has('KEY'), false)
+  })
+
+  test('should get all status for credentials', async () => {
+    const store = new Map([['STRIPE_KEY', 'sk-123']])
+    const meta = {
+      STRIPE_KEY: { name: 'stripe', displayName: 'Stripe' },
+      GITHUB_TOKEN: {
+        name: 'github',
+        displayName: 'GitHub',
+        oauth2: { tokenSecretId: 'GH_TOKEN' },
+      },
+    }
+    const service = new TypedSecretService(createMockSecrets(store), meta)
+    const status = await service.getAllStatus()
+    assert.strictEqual(status.length, 2)
+    const stripeStatus = status.find((s) => s.secretId === 'STRIPE_KEY')!
+    assert.strictEqual(stripeStatus.isConfigured, true)
+    assert.strictEqual(stripeStatus.displayName, 'Stripe')
+    const ghStatus = status.find((s) => s.secretId === 'GITHUB_TOKEN')!
+    assert.strictEqual(ghStatus.isConfigured, false)
+    assert.deepStrictEqual(ghStatus.oauth2, { tokenSecretId: 'GH_TOKEN' })
+  })
+
+  test('should get missing credentials', async () => {
+    const store = new Map([['STRIPE_KEY', 'sk-123']])
+    const meta = {
+      STRIPE_KEY: { name: 'stripe', displayName: 'Stripe' },
+      GITHUB_TOKEN: { name: 'github', displayName: 'GitHub' },
+    }
+    const service = new TypedSecretService(createMockSecrets(store), meta)
+    const missing = await service.getMissing()
+    assert.strictEqual(missing.length, 1)
+    assert.strictEqual(missing[0].secretId, 'GITHUB_TOKEN')
+  })
+})

package/src/services/typed-variables-service.test.ts

@@ -0,0 +1,73 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { TypedVariablesService } from './typed-variables-service.js'
+import { LocalVariablesService } from './local-variables.js'
+
+describe('TypedVariablesService', () => {
+  const createService = (vars: Record<string, string | undefined> = {}) => {
+    const underlying = new LocalVariablesService(vars)
+    const meta = {
+      DB_URL: { name: 'DB_URL', displayName: 'Database URL' },
+      API_KEY: { name: 'API_KEY', displayName: 'API Key' },
+    }
+    return new TypedVariablesService(underlying, meta)
+  }
+
+  test('should delegate get to underlying service', () => {
+    const service = createService({ DB_URL: 'postgres://...' })
+    assert.strictEqual(service.get('DB_URL'), 'postgres://...')
+  })
+
+  test('should delegate set to underlying service', () => {
+    const service = createService()
+    service.set('DB_URL', 'new-value')
+    assert.strictEqual(service.get('DB_URL'), 'new-value')
+  })
+
+  test('should delegate has to underlying service', () => {
+    const service = createService({ DB_URL: 'val' })
+    assert.strictEqual(service.has('DB_URL'), true)
+    assert.strictEqual(service.has('MISSING'), false)
+  })
+
+  test('should delegate delete to underlying service', () => {
+    const service = createService({ DB_URL: 'val' })
+    service.delete('DB_URL')
+    assert.strictEqual(service.has('DB_URL'), false)
+  })
+
+  test('should delegate getJSON to underlying service', () => {
+    const service = createService({ DATA: '{"key":"val"}' })
+    assert.deepStrictEqual(service.getJSON('DATA'), { key: 'val' })
+  })
+
+  test('should delegate setJSON to underlying service', () => {
+    const service = createService()
+    service.setJSON('DATA', { key: 'val' })
+    assert.strictEqual(service.get('DATA'), '{"key":"val"}')
+  })
+
+  test('should get all status for configured variables', async () => {
+    const service = createService({ DB_URL: 'postgres://...' })
+    const status = await service.getAllStatus()
+    assert.strictEqual(status.length, 2)
+    const dbStatus = status.find((s) => s.variableId === 'DB_URL')!
+    assert.strictEqual(dbStatus.isConfigured, true)
+    assert.strictEqual(dbStatus.displayName, 'Database URL')
+    const apiStatus = status.find((s) => s.variableId === 'API_KEY')!
+    assert.strictEqual(apiStatus.isConfigured, false)
+  })
+
+  test('should get missing variables', async () => {
+    const service = createService({ DB_URL: 'val' })
+    const missing = await service.getMissing()
+    assert.strictEqual(missing.length, 1)
+    assert.strictEqual(missing[0].variableId, 'API_KEY')
+  })
+
+  test('should return empty missing when all configured', async () => {
+    const service = createService({ DB_URL: 'val', API_KEY: 'key' })
+    const missing = await service.getMissing()
+    assert.strictEqual(missing.length, 0)
+  })
+})

package/src/services/user-session-service.test.ts

@@ -0,0 +1,113 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import {
+  PikkuSessionService,
+  createMiddlewareSessionWireProps,
+  createFunctionSessionWireProps,
+} from './user-session-service.js'
+
+describe('PikkuSessionService', () => {
+  test('should set and get session', () => {
+    const service = new PikkuSessionService()
+    service.setInitial({ userId: 'user-1' })
+    const session = service.get()
+    assert.deepStrictEqual(session, { userId: 'user-1' })
+  })
+
+  test('should return undefined when no session set', () => {
+    const service = new PikkuSessionService()
+    assert.strictEqual(service.get(), undefined)
+  })
+
+  test('should mark sessionChanged when set is called', () => {
+    const service = new PikkuSessionService()
+    assert.strictEqual(service.sessionChanged, false)
+    service.set({ userId: 'user-1' })
+    assert.strictEqual(service.sessionChanged, true)
+  })
+
+  test('should clear session', () => {
+    const service = new PikkuSessionService()
+    service.setInitial({ userId: 'user-1' })
+    service.clear()
+    assert.strictEqual(service.get(), undefined)
+    assert.strictEqual(service.sessionChanged, true)
+  })
+
+  test('should freeze initial session', () => {
+    const service = new PikkuSessionService()
+    service.setInitial({ userId: 'user-1' })
+    const frozen = service.freezeInitial()
+    assert.deepStrictEqual(frozen, { userId: 'user-1' })
+  })
+
+  test('should only freeze initial once', () => {
+    const service = new PikkuSessionService()
+    service.setInitial({ userId: 'user-1' })
+    service.freezeInitial()
+    service.set({ userId: 'user-2' })
+    const frozen2 = service.freezeInitial()
+    assert.deepStrictEqual(frozen2, { userId: 'user-1' })
+  })
+
+  test('should throw when channelStore provided without channelId', () => {
+    assert.throws(() => new PikkuSessionService({} as any), {
+      message: 'Channel ID is required when using channel store',
+    })
+  })
+
+  test('should use channelStore when provided', async () => {
+    let storedSession: any
+    const store = {
+      setUserSession: (id: string, session: any) => {
+        storedSession = session
+      },
+      getChannelAndSession: (id: string) => ({ session: { userId: 'stored' } }),
+    }
+    const service = new PikkuSessionService(store as any, 'ch-1')
+    service.set({ userId: 'new' })
+    assert.deepStrictEqual(storedSession, { userId: 'new' })
+
+    const session = service.get()
+    assert.deepStrictEqual(session, { userId: 'stored' })
+  })
+})
+
+describe('createMiddlewareSessionWireProps', () => {
+  test('should return session wire props', () => {
+    const service = new PikkuSessionService()
+    service.setInitial({ userId: 'user-1' })
+    const props = createMiddlewareSessionWireProps(service)
+    assert.ok('session' in props)
+    assert.ok('setSession' in props)
+    assert.ok('getSession' in props)
+    assert.ok('hasSessionChanged' in props)
+  })
+
+  test('setSession should call setInitial', () => {
+    const service = new PikkuSessionService()
+    const props = createMiddlewareSessionWireProps(service)
+    props.setSession({ userId: 'user-2' })
+    assert.deepStrictEqual(service.get(), { userId: 'user-2' })
+  })
+})
+
+describe('createFunctionSessionWireProps', () => {
+  test('should return function session wire props', () => {
+    const service = new PikkuSessionService()
+    service.setInitial({ userId: 'user-1' })
+    const props = createFunctionSessionWireProps(service)
+    assert.ok('session' in props)
+    assert.ok('setSession' in props)
+    assert.ok('clearSession' in props)
+    assert.ok('getSession' in props)
+    assert.ok('hasSessionChanged' in props)
+  })
+
+  test('session should be frozen initial', () => {
+    const service = new PikkuSessionService()
+    service.setInitial({ userId: 'user-1' })
+    const props = createFunctionSessionWireProps(service)
+    assert.deepStrictEqual(props.session, { userId: 'user-1' })
+  })
+})

package/src/services/user-session-service.ts

@@ -1,5 +1,5 @@
-import { ChannelStore } from '../wirings/channel/channel-store.js'
-import { CoreUserSession } from '../types/core.types.js'
+import type { ChannelStore } from '../wirings/channel/channel-store.js'
+import type { CoreUserSession } from '../types/core.types.js'
 
 export interface SessionService<UserSession extends CoreUserSession> {
   sessionChanged: boolean
@@ -66,7 +66,7 @@ export function createMiddlewareSessionWireProps<
   UserSession extends CoreUserSession,
 >(session: SessionService<UserSession>) {
   return {
-    session: session.get(),
+    session: session.get() as UserSession | undefined,
     setSession: (s: UserSession) => session.setInitial(s),
     getSession: () => session.get(),
     hasSessionChanged: () => session.sessionChanged,

package/src/services/workflow-service.ts

@@ -1,10 +1,5 @@
-import {
-  SerializedError,
-  CoreSingletonServices,
-  CreateWireServices,
-  CoreConfig,
-} from '../types/core.types.js'
-import {
+import type { SerializedError } from '../types/core.types.js'
+import type {
   WorkflowRun,
   WorkflowRunWire,
   StepState,
@@ -37,11 +32,6 @@ export interface WorkflowService {
 
   // Orchestration operations
   resumeWorkflow(runId: string): Promise<void>
-  setServices(
-    singletonServices: CoreSingletonServices,
-    createWireServices: CreateWireServices | undefined,
-    config: CoreConfig
-  ): void
   startWorkflow<I>(
     name: string,
     input: I,

package/src/time-utils.test.ts

@@ -1,10 +1,10 @@
 import { describe, test } from 'node:test'
 import assert from 'node:assert/strict'
 
+import type { RelativeTimeInput } from './time-utils'
 import {
   getRelativeTimeOffset,
   getRelativeTimeOffsetFromNow,
-  RelativeTimeInput,
 } from './time-utils'
 
 const approxEqual = (a: number, b: number, delta: number = 10): boolean =>