lopata 0.7.0 → 0.8.2

package/src/bindings/workflow.ts

@@ -1,4 +1,6 @@
 import type { Database } from 'bun:sqlite'
+import type { Clock } from '../testing/clock'
+import { realClock } from '../testing/clock'
 import { getActiveContext } from '../tracing/context'
 import { addSpanEvent, persistError, startSpan } from '../tracing/span'
 
@@ -90,6 +92,65 @@ const abortControllers = new Map<string, AbortController>()
 
 const sleepResolvers = new Map<string, () => void>()
 
+// --- Notification hooks (per-process, for testing) ---
+
+const stepCallbacks = new Map<string, Map<string, Set<(output: unknown) => void>>>()
+const sleepCallbacks = new Map<string, Set<() => void>>()
+const eventWaitCallbacks = new Map<string, Map<string, Set<() => void>>>()
+const statusCallbacks = new Map<string, Set<(status: string) => void>>()
+
+// --- Mock registry (per-process, for testing) ---
+
+export interface StepMock {
+	type: 'result' | 'error' | 'timeout'
+	value?: unknown // result value or Error for error type
+	times?: number // how many times to apply (undefined = forever)
+	_used?: number // internal counter
+}
+
+const stepMocks = new Map<string, Map<string, StepMock>>()
+const sleepDisabledInstances = new Set<string>()
+const eventMocks = new Map<string, Map<string, { payload: unknown }>>()
+const eventTimeoutMocks = new Map<string, Set<string>>()
+
+export function registerStepMock(instanceId: string, stepName: string, mock: StepMock): void {
+	let instanceMocks = stepMocks.get(instanceId)
+	if (!instanceMocks) {
+		instanceMocks = new Map()
+		stepMocks.set(instanceId, instanceMocks)
+	}
+	instanceMocks.set(stepName, { ...mock, _used: 0 })
+}
+
+export function registerSleepDisable(instanceId: string): void {
+	sleepDisabledInstances.add(instanceId)
+}
+
+export function registerEventMock(instanceId: string, eventType: string, payload: unknown): void {
+	let instanceMocks = eventMocks.get(instanceId)
+	if (!instanceMocks) {
+		instanceMocks = new Map()
+		eventMocks.set(instanceId, instanceMocks)
+	}
+	instanceMocks.set(eventType, { payload })
+}
+
+export function registerEventTimeoutMock(instanceId: string, eventType: string): void {
+	let instanceMocks = eventTimeoutMocks.get(instanceId)
+	if (!instanceMocks) {
+		instanceMocks = new Set()
+		eventTimeoutMocks.set(instanceId, instanceMocks)
+	}
+	instanceMocks.add(eventType)
+}
+
+export function clearInstanceMocks(instanceId: string): void {
+	stepMocks.delete(instanceId)
+	sleepDisabledInstances.delete(instanceId)
+	eventMocks.delete(instanceId)
+	eventTimeoutMocks.delete(instanceId)
+}
+
 // --- Step ---
 
 class WorkflowStepImpl {
@@ -99,12 +160,14 @@ class WorkflowStepImpl {
 	private stepCount = 0
 	private knownStepNames = new Set<string>()
 	private limits: Required<WorkflowLimits>
+	private clock: Clock
 
-	constructor(abortSignal: AbortSignal, db: Database, instanceId: string, limits: Required<WorkflowLimits>) {
+	constructor(abortSignal: AbortSignal, db: Database, instanceId: string, limits: Required<WorkflowLimits>, clock?: Clock) {
 		this.abortSignal = abortSignal
 		this.db = db
 		this.instanceId = instanceId
 		this.limits = limits
+		this.clock = clock ?? realClock
 	}
 
 	private async checkPaused(): Promise<void> {
@@ -145,7 +208,8 @@ class WorkflowStepImpl {
 		}
 		this.db
 			.query('INSERT OR REPLACE INTO workflow_steps (instance_id, step_name, output, completed_at) VALUES (?, ?, ?, ?)')
-			.run(this.instanceId, name, serialized, Date.now())
+			.run(this.instanceId, name, serialized, this.clock.now())
+		fireStepCallbacks(this.instanceId, name, output)
 	}
 
 	async do<T>(name: string, callbackOrConfig: (() => Promise<T>) | WorkflowStepConfig, maybeCallback?: () => Promise<T>): Promise<T> {
@@ -174,6 +238,29 @@ class WorkflowStepImpl {
 			return JSON.parse(cached.output!) as T
 		}
 
+		// Check step mocks
+		const instanceMocks = stepMocks.get(this.instanceId)
+		const mock = instanceMocks?.get(name)
+		if (mock) {
+			const shouldApply = mock.times === undefined || (mock._used ?? 0) < mock.times
+			if (shouldApply) {
+				mock._used = (mock._used ?? 0) + 1
+				if (mock.type === 'result') {
+					console.log(`  [workflow] step: ${name} (mocked)`)
+					this.cacheStep(name, mock.value)
+					return mock.value as T
+				}
+				if (mock.type === 'error') {
+					console.log(`  [workflow] step: ${name} (mocked error)`)
+					throw mock.value
+				}
+				if (mock.type === 'timeout') {
+					console.log(`  [workflow] step: ${name} (mocked timeout)`)
+					throw new Error(`Step "${name}" timed out (mocked)`)
+				}
+			}
+		}
+
 		console.log(`  [workflow] step: ${name}`)
 
 		return startSpan({
@@ -232,7 +319,7 @@ class WorkflowStepImpl {
 					this.db.query(
 						'INSERT OR REPLACE INTO workflow_step_attempts (instance_id, step_name, failed_attempts, last_error, last_error_name, last_error_id, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)',
 					)
-						.run(this.instanceId, name, attempt + 1, errMsg, errName, errorId, Date.now())
+						.run(this.instanceId, name, attempt + 1, errMsg, errName, errorId, this.clock.now())
 					if (attempt < maxRetries) {
 						const d = computeDelay(delayMs, attempt, backoff)
 						console.log(`  [workflow] step "${name}" attempt ${attempt + 1} failed, retrying in ${d}ms`)
@@ -249,6 +336,13 @@ class WorkflowStepImpl {
 		if (this.abortSignal.aborted) throw new Error('workflow terminated')
 		this.checkDuplicateStepName(`sleep:${name}`)
 
+		// Check if sleeps are disabled for this instance
+		if (sleepDisabledInstances.has(this.instanceId)) {
+			console.log(`  [workflow] sleep: ${name} (disabled)`)
+			this.cacheStep(`sleep:${name}`, { until: this.clock.now() })
+			return
+		}
+
 		console.log(`  [workflow] sleep: ${name}`)
 		return startSpan({
 			name: `sleep ${name}`,
@@ -258,7 +352,7 @@ class WorkflowStepImpl {
 			const cached = this.getCachedStep(`sleep:${name}`)
 			if (cached) {
 				const { until } = JSON.parse(cached.output!) as { until: number }
-				const remaining = Math.max(0, until - Date.now())
+				const remaining = Math.max(0, until - this.clock.now())
 				if (remaining > 0) {
 					await skippableDelay(remaining, this.abortSignal, this.instanceId)
 				}
@@ -269,7 +363,7 @@ class WorkflowStepImpl {
 			if (ms > this.limits.maxSleepMs) {
 				throw new Error(`Sleep duration ${ms}ms exceeds maximum of ${this.limits.maxSleepMs}ms`)
 			}
-			const until = Date.now() + ms
+			const until = this.clock.now() + ms
 			this.cacheStep(`sleep:${name}`, { until })
 
 			if (ms > 0) {
@@ -283,6 +377,14 @@ class WorkflowStepImpl {
 		if (this.abortSignal.aborted) throw new Error('workflow terminated')
 		this.checkDuplicateStepName(`sleepUntil:${name}`)
 
+		// Check if sleeps are disabled for this instance
+		if (sleepDisabledInstances.has(this.instanceId)) {
+			console.log(`  [workflow] sleepUntil: ${name} (disabled)`)
+			const ts = typeof timestamp === 'number' ? new Date(timestamp) : timestamp
+			this.cacheStep(`sleepUntil:${name}`, { until: ts.toISOString() })
+			return
+		}
+
 		const ts = typeof timestamp === 'number' ? new Date(timestamp) : timestamp
 
 		console.log(`  [workflow] sleepUntil: ${name}`)
@@ -293,14 +395,14 @@ class WorkflowStepImpl {
 		}, async () => {
 			const cached = this.getCachedStep(`sleepUntil:${name}`)
 			if (cached) {
-				const remaining = Math.max(0, ts.getTime() - Date.now())
+				const remaining = Math.max(0, ts.getTime() - this.clock.now())
 				if (remaining > 0) {
 					await skippableDelay(remaining, this.abortSignal, this.instanceId)
 				}
 				return
 			}
 
-			const delay = Math.max(0, ts.getTime() - Date.now())
+			const delay = Math.max(0, ts.getTime() - this.clock.now())
 			if (delay > this.limits.maxSleepMs) {
 				throw new Error(`Sleep duration ${delay}ms exceeds maximum of ${this.limits.maxSleepMs}ms`)
 			}
@@ -324,6 +426,23 @@ class WorkflowStepImpl {
 			throw new Error(`Invalid event type "${options.type}". Must be 1-100 characters, only letters, digits, hyphens and underscores.`)
 		}
 
+		// Check event timeout mocks
+		const timeoutMocks = eventTimeoutMocks.get(this.instanceId)
+		if (timeoutMocks?.has(options.type)) {
+			console.log(`  [workflow] waitForEvent: ${name} (mocked timeout)`)
+			throw new Error(`waitForEvent timed out (mocked)`)
+		}
+
+		// Check event mocks — pre-insert into DB so existing flow picks them up
+		const instanceEventMocks = eventMocks.get(this.instanceId)
+		const eventMock = instanceEventMocks?.get(options.type)
+		if (eventMock) {
+			instanceEventMocks!.delete(options.type)
+			this.db
+				.query('INSERT INTO workflow_events (instance_id, event_type, payload, created_at) VALUES (?, ?, ?, ?)')
+				.run(this.instanceId, options.type, eventMock.payload !== undefined ? JSON.stringify(eventMock.payload) : null, this.clock.now())
+		}
+
 		console.log(`  [workflow] waitForEvent: ${name} (type: ${options.type})`)
 		return startSpan({
 			name: `waitForEvent ${name}`,
@@ -345,7 +464,7 @@ class WorkflowStepImpl {
 			// Update status to waiting
 			this.db
 				.query("UPDATE workflow_instances SET status = 'waiting', updated_at = ? WHERE id = ?")
-				.run(Date.now(), this.instanceId)
+				.run(this.clock.now(), this.instanceId)
 
 			// Check if event already exists in DB
 			const existing = this.db
@@ -358,7 +477,7 @@ class WorkflowStepImpl {
 					.run(this.instanceId, options.type)
 				this.db
 					.query("UPDATE workflow_instances SET status = 'running', updated_at = ? WHERE id = ?")
-					.run(Date.now(), this.instanceId)
+					.run(this.clock.now(), this.instanceId)
 				const payload = (existing.payload !== null ? JSON.parse(existing.payload) : undefined) as T
 				const event = { payload, timestamp: new Date(existing.created_at), type: options.type }
 				this.cacheStep(`waitForEvent:${name}`, event)
@@ -400,12 +519,13 @@ class WorkflowStepImpl {
 					reject(new Error('workflow terminated'))
 				}
 				this.abortSignal.addEventListener('abort', abortHandler)
+				fireEventWaitCallbacks(this.instanceId, options.type)
 			})
 
 			// Restore running status
 			this.db
 				.query("UPDATE workflow_instances SET status = 'running', updated_at = ? WHERE id = ?")
-				.run(Date.now(), this.instanceId)
+				.run(this.clock.now(), this.instanceId)
 
 			this.cacheStep(`waitForEvent:${name}`, result)
 			return result
@@ -467,6 +587,7 @@ function skippableDelay(ms: number, abortSignal: AbortSignal, instanceId: string
 			resolve()
 		})
 		abortSignal.addEventListener('abort', abortHandler)
+		fireSleepCallbacks(instanceId)
 	})
 }
 
@@ -482,6 +603,104 @@ export function isInstanceSleeping(instanceId: string): boolean {
 	return sleepResolvers.has(instanceId)
 }
 
+// --- Notification hook registration (for testing) ---
+
+function fireStepCallbacks(instanceId: string, stepName: string, output: unknown): void {
+	const instanceCbs = stepCallbacks.get(instanceId)
+	if (!instanceCbs) return
+	const cbs = instanceCbs.get(stepName)
+	if (!cbs) return
+	for (const cb of cbs) cb(output)
+}
+
+function fireSleepCallbacks(instanceId: string): void {
+	const cbs = sleepCallbacks.get(instanceId)
+	if (!cbs) return
+	for (const cb of cbs) cb()
+}
+
+function fireEventWaitCallbacks(instanceId: string, eventType: string): void {
+	const instanceCbs = eventWaitCallbacks.get(instanceId)
+	if (!instanceCbs) return
+	const cbs = instanceCbs.get(eventType)
+	if (!cbs) return
+	for (const cb of cbs) cb()
+}
+
+function fireStatusCallbacks(instanceId: string, status: string): void {
+	const cbs = statusCallbacks.get(instanceId)
+	if (!cbs) return
+	for (const cb of cbs) cb(status)
+}
+
+/** Register a callback for when a step completes. Returns an unsubscribe function. */
+export function onStepComplete(instanceId: string, stepName: string, cb: (output: unknown) => void): () => void {
+	let instanceCbs = stepCallbacks.get(instanceId)
+	if (!instanceCbs) {
+		instanceCbs = new Map()
+		stepCallbacks.set(instanceId, instanceCbs)
+	}
+	let cbs = instanceCbs.get(stepName)
+	if (!cbs) {
+		cbs = new Set()
+		instanceCbs.set(stepName, cbs)
+	}
+	cbs.add(cb)
+	return () => {
+		cbs!.delete(cb)
+		if (cbs!.size === 0) instanceCbs!.delete(stepName)
+		if (instanceCbs!.size === 0) stepCallbacks.delete(instanceId)
+	}
+}
+
+/** Register a callback for when the instance starts sleeping. Returns an unsubscribe function. */
+export function onSleepRegistered(instanceId: string, cb: () => void): () => void {
+	let cbs = sleepCallbacks.get(instanceId)
+	if (!cbs) {
+		cbs = new Set()
+		sleepCallbacks.set(instanceId, cbs)
+	}
+	cbs.add(cb)
+	return () => {
+		cbs!.delete(cb)
+		if (cbs!.size === 0) sleepCallbacks.delete(instanceId)
+	}
+}
+
+/** Register a callback for when the instance starts waiting for an event. Returns an unsubscribe function. */
+export function onEventWaitRegistered(instanceId: string, eventType: string, cb: () => void): () => void {
+	let instanceCbs = eventWaitCallbacks.get(instanceId)
+	if (!instanceCbs) {
+		instanceCbs = new Map()
+		eventWaitCallbacks.set(instanceId, instanceCbs)
+	}
+	let cbs = instanceCbs.get(eventType)
+	if (!cbs) {
+		cbs = new Set()
+		instanceCbs.set(eventType, cbs)
+	}
+	cbs.add(cb)
+	return () => {
+		cbs!.delete(cb)
+		if (cbs!.size === 0) instanceCbs!.delete(eventType)
+		if (instanceCbs!.size === 0) eventWaitCallbacks.delete(instanceId)
+	}
+}
+
+/** Register a callback for when the instance status changes. Returns an unsubscribe function. */
+export function onStatusChange(instanceId: string, cb: (status: string) => void): () => void {
+	let cbs = statusCallbacks.get(instanceId)
+	if (!cbs) {
+		cbs = new Set()
+		statusCallbacks.set(instanceId, cbs)
+	}
+	cbs.add(cb)
+	return () => {
+		cbs!.delete(cb)
+		if (cbs!.size === 0) statusCallbacks.delete(instanceId)
+	}
+}
+
 export function parseDuration(duration: string | number): number {
 	if (typeof duration === 'number') return duration
 	const match = duration.match(/^(\d+)\s*(ms|milliseconds?|s|seconds?|m|minutes?|h|hours?|d|days?|w|weeks?|months?|y|years?)$/i)
@@ -567,6 +786,7 @@ export class SqliteWorkflowInstance {
 		// Abort via global registry so get()-retrieved instances also work
 		const ac = abortControllers.get(this.instanceId)
 		ac?.abort()
+		fireStatusCallbacks(this.instanceId, 'terminated')
 	}
 
 	async restart(options?: { fromStep?: string }): Promise<void> {
@@ -659,12 +879,14 @@ export class SqliteWorkflowBinding {
 	private _env?: unknown
 	private counter = 0
 	private limits: Required<WorkflowLimits>
+	private clock: Clock
 
-	constructor(db: Database, workflowName: string, className: string, limits?: WorkflowLimits) {
+	constructor(db: Database, workflowName: string, className: string, limits?: WorkflowLimits, clock?: Clock) {
 		this.db = db
 		this.workflowName = workflowName
 		this.className = className
 		this.limits = { ...WORKFLOW_DEFAULTS, ...limits }
+		this.clock = clock ?? realClock
 	}
 
 	_setClass(cls: new(ctx: unknown, env: unknown) => WorkflowEntrypointBase, env: unknown) {
@@ -687,6 +909,9 @@ export class SqliteWorkflowBinding {
 	_getLimits() {
 		return this.limits
 	}
+	_getClock() {
+		return this.clock
+	}
 
 	/** Abort all running/queued/waiting instances for this workflow */
 	abortRunning(): void {
@@ -700,7 +925,7 @@ export class SqliteWorkflowBinding {
 
 	private cleanupRetentionExpired(): void {
 		if (this.limits.maxRetentionMs <= 0) return
-		const cutoff = Date.now() - this.limits.maxRetentionMs
+		const cutoff = this.clock.now() - this.limits.maxRetentionMs
 		// Clean up step attempts for instances being deleted
 		const expiredIds = this.db
 			.query("SELECT id FROM workflow_instances WHERE workflow_name = ? AND status IN ('complete', 'errored') AND updated_at < ?")
@@ -725,7 +950,7 @@ export class SqliteWorkflowBinding {
 
 		this.cleanupRetentionExpired()
 
-		const id = options?.id ?? `wf-${++this.counter}-${Date.now()}`
+		const id = options?.id ?? `wf-${++this.counter}-${this.clock.now()}`
 		if (id.length > this.limits.maxInstanceIdLength) {
 			throw new Error(`Workflow instance ID must be ${this.limits.maxInstanceIdLength} characters or fewer, got ${id.length}`)
 		}
@@ -735,7 +960,7 @@ export class SqliteWorkflowBinding {
 		if (existing) throw new Error(`Workflow instance with ID "${id}" already exists`)
 
 		const params = options?.params ?? {}
-		const now = Date.now()
+		const now = this.clock.now()
 
 		// Check concurrency
 		const isQueued = this.limits.maxConcurrentInstances !== Infinity && this.countRunning() >= this.limits.maxConcurrentInstances
@@ -753,7 +978,18 @@ export class SqliteWorkflowBinding {
 
 		if (!isQueued) {
 			console.log(`[workflow] started ${id}`)
-			SqliteWorkflowBinding.executeWorkflow(this.db, id, this._class, this._env, params, abortController, this.workflowName, this.limits, now)
+			SqliteWorkflowBinding.executeWorkflow(
+				this.db,
+				id,
+				this._class,
+				this._env,
+				params,
+				abortController,
+				this.workflowName,
+				this.limits,
+				now,
+				this.clock,
+			)
 		} else {
 			console.log(`[workflow] queued ${id} (concurrency limit: ${this.limits.maxConcurrentInstances})`)
 		}
@@ -761,6 +997,60 @@ export class SqliteWorkflowBinding {
 		return handle
 	}
 
+	/** Create a workflow instance without starting execution. Call _executeInstance() to start it. */
+	async _createPrepared(options?: { id?: string; params?: unknown }): Promise<SqliteWorkflowInstance> {
+		if (!this._class) throw new Error('Workflow class not wired yet')
+
+		this.cleanupRetentionExpired()
+
+		const id = options?.id ?? `wf-${++this.counter}-${this.clock.now()}`
+		if (id.length > this.limits.maxInstanceIdLength) {
+			throw new Error(`Workflow instance ID must be ${this.limits.maxInstanceIdLength} characters or fewer, got ${id.length}`)
+		}
+
+		const existing = this.db.query('SELECT id FROM workflow_instances WHERE id = ?').get(id)
+		if (existing) throw new Error(`Workflow instance with ID "${id}" already exists`)
+
+		const params = options?.params ?? {}
+		const now = this.clock.now()
+
+		this.db
+			.query(
+				'INSERT INTO workflow_instances (id, workflow_name, class_name, params, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)',
+			)
+			.run(id, this.workflowName, this.className, JSON.stringify(params), 'queued', now, now)
+
+		const abortController = new AbortController()
+		abortControllers.set(id, abortController)
+
+		return new SqliteWorkflowInstance(this.db, id, this)
+	}
+
+	/** Start execution of a prepared (queued) workflow instance. */
+	_executeInstance(id: string): void {
+		if (!this._class) throw new Error('Workflow class not wired yet')
+
+		const row = this.db
+			.query('SELECT params, created_at FROM workflow_instances WHERE id = ?')
+			.get(id) as { params: string | null; created_at: number } | null
+		if (!row) throw new Error(`Workflow instance ${id} not found`)
+
+		const params = row.params !== null ? JSON.parse(row.params) : {}
+
+		this.db
+			.query("UPDATE workflow_instances SET status = 'running', updated_at = ? WHERE id = ?")
+			.run(this.clock.now(), id)
+
+		let ac = abortControllers.get(id)
+		if (!ac) {
+			ac = new AbortController()
+			abortControllers.set(id, ac)
+		}
+
+		console.log(`[workflow] started ${id}`)
+		SqliteWorkflowBinding.executeWorkflow(this.db, id, this._class, this._env, params, ac, this.workflowName, this.limits, row.created_at, this.clock)
+	}
+
 	async createBatch(batch: { id?: string; params?: unknown }[]): Promise<SqliteWorkflowInstance[]> {
 		if (batch.length > this.limits.maxBatchSize) {
 			throw new Error(`Batch size ${batch.length} exceeds maximum of ${this.limits.maxBatchSize}`)
@@ -797,7 +1087,7 @@ export class SqliteWorkflowBinding {
 			// Reset to running before re-executing (waiting status needs to restart from last checkpoint)
 			this.db
 				.query("UPDATE workflow_instances SET status = 'running', updated_at = ? WHERE id = ?")
-				.run(Date.now(), row.id)
+				.run(this.clock.now(), row.id)
 			SqliteWorkflowBinding.executeWorkflow(
 				this.db,
 				row.id,
@@ -808,6 +1098,7 @@ export class SqliteWorkflowBinding {
 				this.workflowName,
 				this.limits,
 				row.created_at,
+				this.clock,
 			)
 		}
 	}
@@ -825,7 +1116,7 @@ export class SqliteWorkflowBinding {
 
 			this.db
 				.query("UPDATE workflow_instances SET status = 'running', updated_at = ? WHERE id = ?")
-				.run(Date.now(), queued.id)
+				.run(this.clock.now(), queued.id)
 
 			const abortController = new AbortController()
 			abortControllers.set(queued.id, abortController)
@@ -841,6 +1132,7 @@ export class SqliteWorkflowBinding {
 				this.workflowName,
 				this.limits,
 				queued.created_at,
+				this.clock,
 			)
 		}
 	}
@@ -855,14 +1147,16 @@ export class SqliteWorkflowBinding {
 		workflowName?: string,
 		limits?: Required<WorkflowLimits>,
 		createdAt?: number,
+		clock?: Clock,
 	): void {
 		const resolvedLimits = limits ?? WORKFLOW_DEFAULTS
-		const instance = new workflowClass({}, env)
-		const step = new WorkflowStepImpl(abortController.signal, db, id, resolvedLimits)
-		const event = { payload: params, timestamp: new Date(createdAt ?? Date.now()), instanceId: id }
+		const resolvedClock = clock ?? realClock
 		;(async () => {
 			let workflowTraceId: string | undefined
 			try {
+				const instance = new workflowClass({}, env)
+				const step = new WorkflowStepImpl(abortController.signal, db, id, resolvedLimits, resolvedClock)
+				const event = { payload: params, timestamp: new Date(createdAt ?? resolvedClock.now()), instanceId: id }
 				const result = await startSpan({
 					name: `workflow ${workflowName ?? 'run'}`,
 					kind: 'server',
@@ -875,10 +1169,11 @@ export class SqliteWorkflowBinding {
 				})
 				if (abortController.signal.aborted) return
 				db.query("UPDATE workflow_instances SET status = 'complete', output = ?, updated_at = ? WHERE id = ?")
-					.run(JSON.stringify(result), Date.now(), id)
+					.run(JSON.stringify(result), resolvedClock.now(), id)
 				// Clean up step attempts on successful completion
 				db.query('DELETE FROM workflow_step_attempts WHERE instance_id = ?').run(id)
 				console.log(`[workflow] completed ${id}:`, result)
+				fireStatusCallbacks(id, 'complete')
 			} catch (err) {
 				const errorName = err instanceof Error ? (err.name || err.constructor.name || 'Error') : 'Error'
 				const message = err instanceof Error ? err.message : String(err)
@@ -886,14 +1181,15 @@ export class SqliteWorkflowBinding {
 				if (abortController.signal.aborted) {
 					// Terminated — store error info but keep "terminated" status
 					db.query('UPDATE workflow_instances SET error = ?, error_name = ?, updated_at = ? WHERE id = ?')
-						.run(message, errorName, Date.now(), id)
+						.run(message, errorName, resolvedClock.now(), id)
 					persistError(err, 'workflow', workflowName, workflowTraceId)
 					return
 				}
 				db.query("UPDATE workflow_instances SET status = 'errored', error = ?, error_name = ?, updated_at = ? WHERE id = ?")
-					.run(message, errorName, Date.now(), id)
+					.run(message, errorName, resolvedClock.now(), id)
 				console.error(`[workflow] failed ${id}:`, err)
 				persistError(err, 'workflow', workflowName, workflowTraceId)
+				fireStatusCallbacks(id, 'errored')
 			} finally {
 				eventWaiters.delete(id)
 				abortControllers.delete(id)
@@ -905,12 +1201,23 @@ export class SqliteWorkflowBinding {
 						.get(workflowName) as { id: string; params: string | null; created_at: number } | null
 					if (queued) {
 						db.query("UPDATE workflow_instances SET status = 'running', updated_at = ? WHERE id = ?")
-							.run(Date.now(), queued.id)
+							.run(resolvedClock.now(), queued.id)
 						const qParams = queued.params !== null ? JSON.parse(queued.params) : {}
 						const ac = new AbortController()
 						abortControllers.set(queued.id, ac)
 						console.log(`[workflow] starting queued instance ${queued.id}`)
-						SqliteWorkflowBinding.executeWorkflow(db, queued.id, workflowClass, env, qParams, ac, workflowName, resolvedLimits, queued.created_at)
+						SqliteWorkflowBinding.executeWorkflow(
+							db,
+							queued.id,
+							workflowClass,
+							env,
+							qParams,
+							ac,
+							workflowName,
+							resolvedLimits,
+							queued.created_at,
+							resolvedClock,
+						)
 					}
 				}
 			}

package/src/env.ts

@@ -321,7 +321,7 @@ export function buildEnv(
 
 	// Static assets
 	if (config.assets) {
-		const assetsDir = path.resolve(config.assets.directory)
+		const assetsDir = devVarsDir ? path.resolve(devVarsDir, config.assets.directory) : path.resolve(config.assets.directory)
 		const assets = new StaticAssets(assetsDir, config.assets.html_handling, config.assets.not_found_handling)
 		registry.staticAssets = assets
 		if (config.assets.binding) {
@@ -363,11 +363,12 @@ export function wireClassRefs(
 	workerModule: Record<string, unknown>,
 	env: Record<string, unknown>,
 	workerRegistry?: WorkerRegistry,
+	generationId?: number,
 ) {
 	for (const entry of registry.durableObjects) {
 		const cls = workerModule[entry.className]
 		if (!cls) throw new Error(`Durable Object class "${entry.className}" not exported from worker module`)
-		entry.namespace._setClass(cls as any, env)
+		entry.namespace._setClass(cls as any, env, generationId)
 		console.log(`[lopata] Wired DO class: ${entry.className}`)
 	}