lopata 0.2.1 → 0.3.1

package/src/bindings/service-binding.ts

@@ -37,10 +37,13 @@ export class ServiceBinding {
 	private _limits: Required<ServiceBindingLimits>
 	_subrequestCount: number = 0
 
-	constructor(serviceName: string, entrypoint?: string, limits?: ServiceBindingLimits) {
+	private _props: Record<string, unknown>
+
+	constructor(serviceName: string, entrypoint?: string, limits?: ServiceBindingLimits, props?: Record<string, unknown>) {
 		this._serviceName = serviceName
 		this._entrypoint = entrypoint
 		this._limits = { ...SERVICE_BINDING_DEFAULTS, ...limits }
+		this._props = props ?? {}
 	}
 
 	_wire(
@@ -80,24 +83,25 @@ export class ServiceBinding {
 
 	private _getTarget(ctx?: ExecutionContext): Record<string, unknown> {
 		const { workerModule, env } = this._resolve()
+		const execCtx = ctx ?? new ExecutionContext(this._props)
 		if (this._entrypoint) {
 			const cls = workerModule[this._entrypoint] as (new(...args: unknown[]) => Record<string, unknown>) | undefined
 			if (!cls) {
 				throw new Error(`Entrypoint "${this._entrypoint}" not exported from worker module`)
 			}
-			return new cls(ctx ?? new ExecutionContext(), env)
+			return new cls(execCtx, env)
 		}
 		// Default export: could be class-based or object-based
 		const def = workerModule.default
 		if (typeof def === 'function' && def.prototype && typeof def.prototype.fetch === 'function') {
-			return new (def as new(ctx: ExecutionContext, env: unknown) => Record<string, unknown>)(ctx ?? new ExecutionContext(), env)
+			return new (def as new(ctx: ExecutionContext, env: unknown) => Record<string, unknown>)(execCtx, env)
 		}
 		return def as Record<string, unknown>
 	}
 
 	async fetch(input: Request | string | URL, init?: RequestInit): Promise<Response> {
 		this._checkSubrequestLimit()
-		const execCtx = new ExecutionContext()
+		const execCtx = new ExecutionContext(this._props)
 		const target = this._getTarget(execCtx)
 		if (!target?.fetch || typeof target.fetch !== 'function') {
 			throw new Error(`Service binding "${this._serviceName}" target has no fetch() handler`)
@@ -214,7 +218,8 @@ export function createServiceBinding(
 	serviceName: string,
 	entrypoint?: string,
 	limits?: ServiceBindingLimits,
+	props?: Record<string, unknown>,
 ): Record<string, unknown> {
-	const binding = new ServiceBinding(serviceName, entrypoint, limits)
+	const binding = new ServiceBinding(serviceName, entrypoint, limits, props)
 	return binding.toProxy()
 }

package/src/bindings/static-assets.ts

@@ -26,6 +26,7 @@ const STATIC_ASSETS_LIMITS_DEFAULTS: Required<StaticAssetsLimits> = {
 interface HeaderRule {
 	pattern: string
 	headers: Record<string, string>
+	removals: string[]
 }
 
 interface RedirectRule {
@@ -277,6 +278,9 @@ export class StaticAssets {
 				for (const [key, value] of Object.entries(rule.headers)) {
 					headers.set(key, value)
 				}
+				for (const name of rule.removals) {
+					headers.delete(name)
+				}
 			}
 		}
 	}
@@ -339,6 +343,14 @@ export function parseHeadersFile(content: string, limits: Required<StaticAssetsL
 		if (line.startsWith(' ') || line.startsWith('\t')) {
 			if (!currentRule) continue
 			const trimmed = line.trim()
+			// Header removal: ! Header-Name
+			if (trimmed.startsWith('!')) {
+				const headerName = trimmed.slice(1).trim()
+				if (headerName) {
+					currentRule.removals.push(headerName)
+				}
+				continue
+			}
 			const colonIdx = trimmed.indexOf(':')
 			if (colonIdx === -1) continue
 			const key = trimmed.slice(0, colonIdx).trim()
@@ -351,7 +363,7 @@ export function parseHeadersFile(content: string, limits: Required<StaticAssetsL
 			if (rules.length >= limits.maxHeaderRules) {
 				break // reached rule limit
 			}
-			currentRule = { pattern: line.trim(), headers: {} }
+			currentRule = { pattern: line.trim(), headers: {}, removals: [] }
 			rules.push(currentRule)
 		}
 	}

package/src/bindings/workflow.ts

@@ -552,9 +552,12 @@ export class SqliteWorkflowInstance {
 	}
 
 	async resume(): Promise<void> {
+		// If workflow was waiting for an event before pause, restore 'waiting' status
+		const waiters = eventWaiters.get(this.instanceId)
+		const newStatus = (waiters && waiters.size > 0) ? 'waiting' : 'running'
 		this.db
-			.query("UPDATE workflow_instances SET status = 'running', updated_at = ? WHERE id = ? AND status = 'paused'")
-			.run(Date.now(), this.instanceId)
+			.query("UPDATE workflow_instances SET status = ?, updated_at = ? WHERE id = ? AND status = 'paused'")
+			.run(newStatus, Date.now(), this.instanceId)
 	}
 
 	async terminate(): Promise<void> {

package/src/cli/dev.ts

@@ -3,7 +3,7 @@ Error.stackTraceLimit = 50
 
 import '../plugin'
 import path from 'node:path'
-import { handleApiRequest, setDashboardConfig, setGenerationManager, setWorkerRegistry } from '../api'
+import { handleApiRequest, setDashboardConfig, setGenerationManager, setLopataConfig, setWorkerRegistry } from '../api'
 import { QueuePullConsumer } from '../bindings/queue'
 import type { AckRequest, PullRequest } from '../bindings/queue'
 import { CFWebSocket } from '../bindings/websocket-pair'
@@ -36,6 +36,7 @@ export async function run(ctx: CliContext) {
 	if (lopataConfig) {
 		// ─── Multi-worker mode ─────────────────────────────────────────
 		console.log('[lopata] Multi-worker mode (lopata.config.ts found)')
+		setLopataConfig(lopataConfig)
 
 		// Create executor factory based on isolation mode
 		let executorFactory: import('../bindings/do-executor').DOExecutorFactory | undefined

package/src/config.ts

@@ -17,7 +17,15 @@ export interface WranglerConfig {
 	d1_databases?: { binding: string; database_name: string; database_id: string; migrations_dir?: string }[]
 	queues?: {
 		producers?: { binding: string; queue: string; delivery_delay?: number }[]
-		consumers?: { queue: string; max_batch_size?: number; max_batch_timeout?: number; max_retries?: number; dead_letter_queue?: string }[]
+		consumers?: {
+			queue: string
+			max_batch_size?: number
+			max_batch_timeout?: number
+			max_retries?: number
+			dead_letter_queue?: string
+			max_concurrency?: number
+			retry_delay?: number
+		}[]
 	}
 	send_email?: {
 		name: string
@@ -30,7 +38,7 @@ export interface WranglerConfig {
 		id: string
 		localConnectionString?: string
 	}[]
-	services?: { binding: string; service: string; entrypoint?: string }[]
+	services?: { binding: string; service: string; entrypoint?: string; props?: Record<string, unknown> }[]
 	triggers?: { crons?: string[] }
 	vars?: Record<string, string>
 	assets?: {
@@ -53,7 +61,13 @@ export interface WranglerConfig {
 	analytics_engine_datasets?: { binding: string; dataset?: string }[]
 	browser?: { binding: string }
 	version_metadata?: { binding: string }
-	migrations?: { tag: string; new_classes?: string[]; new_sqlite_classes?: string[] }[]
+	migrations?: {
+		tag: string
+		new_classes?: string[]
+		new_sqlite_classes?: string[]
+		renamed_classes?: { from: string; to: string }[]
+		deleted_classes?: string[]
+	}[]
 	env?: Record<string, Partial<Omit<WranglerConfig, 'env'>>>
 }
 

package/src/dashboard-serve.ts

@@ -77,7 +77,7 @@ export function handleDashboardRequest(request: Request): Response {
 	if (assetMatch && dashboardAssets) {
 		const asset = dashboardAssets.get(assetMatch[1]!)
 		if (asset) {
-			return new Response(asset.content as unknown as BodyInit, {
+			return new Response(asset.content as unknown as Bun.BodyInit, {
 				headers: {
 					'Content-Type': asset.contentType,
 					'Cache-Control': 'public, max-age=31536000, immutable',

package/src/db.ts

@@ -250,6 +250,12 @@ export function runMigrations(db: Database): void {
 		)
 	`)
 	db.run(`CREATE INDEX IF NOT EXISTS idx_analytics_engine_dataset_ts ON analytics_engine(dataset, timestamp)`)
+
+	db.run(`
+		CREATE TABLE IF NOT EXISTS do_migrations (
+			tag TEXT PRIMARY KEY
+		)
+	`)
 }
 
 /** Returns the path to the .lopata data directory. */

package/src/env.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync, renameSync, rmSync } from 'node:fs'
 import path from 'node:path'
 import { AiBinding } from './bindings/ai'
 import { SqliteAnalyticsEngine } from './bindings/analytics-engine'
@@ -60,6 +60,8 @@ interface ConsumerConfig {
 	maxBatchTimeout: number
 	maxRetries: number
 	deadLetterQueue: string | null
+	maxConcurrency: number | null
+	retryDelay: number | null
 }
 
 interface ServiceBindingEntry {
@@ -111,6 +113,40 @@ export function buildEnv(
 
 	// KV namespaces
 	const db = getDatabase()
+
+	// DO migrations (renamed_classes, deleted_classes)
+	if (config.migrations) {
+		for (const migration of config.migrations) {
+			const applied = db.query('SELECT 1 FROM do_migrations WHERE tag = ?').get(migration.tag)
+			if (applied) continue
+
+			for (const { from, to } of migration.renamed_classes ?? []) {
+				db.run('UPDATE do_storage SET namespace = ? WHERE namespace = ?', [to, from])
+				db.run('UPDATE do_alarms SET namespace = ? WHERE namespace = ?', [to, from])
+				db.run('UPDATE do_instances SET namespace = ? WHERE namespace = ?', [to, from])
+				const fromDir = path.join(getDataDir(), 'do-sql', from)
+				const toDir = path.join(getDataDir(), 'do-sql', to)
+				if (existsSync(fromDir)) {
+					renameSync(fromDir, toDir)
+				}
+				console.log(`[lopata] Migration ${migration.tag}: renamed DO class ${from} → ${to}`)
+			}
+
+			for (const className of migration.deleted_classes ?? []) {
+				db.run('DELETE FROM do_storage WHERE namespace = ?', [className])
+				db.run('DELETE FROM do_alarms WHERE namespace = ?', [className])
+				db.run('DELETE FROM do_instances WHERE namespace = ?', [className])
+				const classDir = path.join(getDataDir(), 'do-sql', className)
+				if (existsSync(classDir)) {
+					rmSync(classDir, { recursive: true })
+				}
+				console.log(`[lopata] Migration ${migration.tag}: deleted DO class ${className}`)
+			}
+
+			db.run('INSERT INTO do_migrations (tag) VALUES (?)', [migration.tag])
+		}
+	}
+
 	for (const kv of config.kv_namespaces ?? []) {
 		console.log(`[lopata] KV namespace: ${kv.binding}`)
 		env[kv.binding] = instrumentBinding(new SqliteKVNamespace(db, kv.id), {
@@ -183,13 +219,15 @@ export function buildEnv(
 			maxBatchTimeout: consumer.max_batch_timeout ?? 5,
 			maxRetries: consumer.max_retries ?? 3,
 			deadLetterQueue: consumer.dead_letter_queue ?? null,
+			maxConcurrency: consumer.max_concurrency ?? null,
+			retryDelay: consumer.retry_delay ?? null,
 		})
 	}
 
 	// Service bindings
 	for (const svc of config.services ?? []) {
 		console.log(`[lopata] Service binding: ${svc.binding} -> ${svc.service}${svc.entrypoint ? ` (${svc.entrypoint})` : ''}`)
-		const proxy = createServiceBinding(svc.service, svc.entrypoint)
+		const proxy = createServiceBinding(svc.service, svc.entrypoint, undefined, svc.props)
 		env[svc.binding] = instrumentServiceBinding(proxy as object, svc.service) as Record<string, unknown>
 		registry.serviceBindings.push({
 			bindingName: svc.binding,

package/src/execution-context.ts

@@ -12,6 +12,11 @@ export function runWithExecutionContext<T>(ctx: ExecutionContext, fn: () => T):
 
 export class ExecutionContext {
 	private _promises: Promise<unknown>[] = []
+	readonly props: Record<string, unknown>
+
+	constructor(props?: Record<string, unknown>) {
+		this.props = props ?? {}
+	}
 
 	waitUntil(promise: Promise<unknown>): void {
 		this._promises.push(promise.catch(err => {

package/src/generation-manager.ts

@@ -165,12 +165,16 @@ export class GenerationManager {
 			setGlobalEnv(env)
 		}
 
-		// 5. Validate default export
+		// 5. Validate default export (or service worker fetch handler)
 		const defaultExport = workerModule.default
 		const classBasedExport = isEntrypointClass(defaultExport)
+		const swHandlers = (globalThis as any).__lopata_sw_handlers as { fetch?: (event: any) => void } | undefined
+		const hasServiceWorkerFetch = !!swHandlers?.fetch
 
-		if (!classBasedExport && !defaultExport?.fetch) {
-			throw new Error('Worker module must export a default object with a fetch() method, or a class with a fetch() method on its prototype')
+		if (!classBasedExport && !defaultExport?.fetch && !hasServiceWorkerFetch) {
+			throw new Error(
+				'Worker module must export a default object with a fetch() method, a class with a fetch() method on its prototype, or use addEventListener("fetch", handler)',
+			)
 		}
 
 		// 5b. Patch frameworks that use .then()/.catch() for dispatch (e.g. Hono)

package/src/generation.ts

@@ -16,7 +16,15 @@ interface ClassRegistry {
 	durableObjects: { bindingName: string; className: string; namespace: DurableObjectNamespaceImpl }[]
 	workflows: { bindingName: string; className: string; binding: SqliteWorkflowBinding }[]
 	containers: { className: string; image: string; maxInstances?: number; namespace: DurableObjectNamespaceImpl }[]
-	queueConsumers: { queue: string; maxBatchSize: number; maxBatchTimeout: number; maxRetries: number; deadLetterQueue: string | null }[]
+	queueConsumers: {
+		queue: string
+		maxBatchSize: number
+		maxBatchTimeout: number
+		maxRetries: number
+		deadLetterQueue: string | null
+		maxConcurrency: number | null
+		retryDelay: number | null
+	}[]
 	serviceBindings: { bindingName: string; serviceName: string; entrypoint?: string; proxy: Record<string, unknown> }[]
 	staticAssets: { fetch(req: Request): Promise<Response> } | null
 }
@@ -109,7 +117,28 @@ export class Generation {
 						const instance = new (this.defaultExport as new(ctx: ExecutionContext, env: unknown) => Record<string, unknown>)(ctx, this.env)
 						return await (instance.fetch as (r: Request) => Promise<Response>)(req)
 					}
-					return await (this.defaultExport as { fetch: Function }).fetch(req, this.env, ctx) as Response
+					if ((this.defaultExport as Record<string, unknown>)?.fetch) {
+						return await (this.defaultExport as { fetch: Function }).fetch(req, this.env, ctx) as Response
+					}
+					// Service worker syntax: addEventListener("fetch", handler)
+					const swHandlers = (globalThis as any).__lopata_sw_handlers as { fetch?: (event: any) => void } | undefined
+					if (swHandlers?.fetch) {
+						return await new Promise<Response>((resolve, reject) => {
+							const event = {
+								type: 'fetch',
+								request: req,
+								respondWith(response: Response | Promise<Response>) {
+									Promise.resolve(response).then(resolve, reject)
+								},
+								waitUntil(promise: Promise<unknown>) {
+									ctx.waitUntil(promise)
+								},
+								passThroughOnException() {},
+							}
+							swHandlers.fetch!(event)
+						})
+					}
+					throw new Error('No fetch handler found')
 				}
 
 				const handleResponse = (response: Response): Response | undefined => {

package/src/lopata-config.ts

@@ -17,6 +17,13 @@ export interface LopataConfig {
 	 * - "isolated" — each DO instance runs in a separate Bun Worker thread (faithful to CF production)
 	 */
 	isolation?: 'dev' | 'isolated'
+	/** AI SQL generation config for the D1 console */
+	ai?: {
+		/** OpenRouter API key (fallback: OPENROUTER_API_KEY env var) */
+		apiKey?: string
+		/** Model to use (default: "anthropic/claude-haiku-4.5") */
+		model?: string
+	}
 	/** Browser Rendering binding config for local dev */
 	browser?: {
 		/** WS endpoint of an existing Chrome instance. If set, uses puppeteer-core connect(). */

package/src/plugin.ts

@@ -7,6 +7,7 @@ import { patchGlobalCrypto } from './bindings/crypto-extras'
 import { DurableObjectBase, WebSocketRequestResponsePair } from './bindings/durable-object'
 import { EmailMessage } from './bindings/email'
 import { HTMLRewriter } from './bindings/html-rewriter'
+import type { ImageTransformOptions, OutputOptions } from './bindings/images'
 import { WebSocketPair } from './bindings/websocket-pair'
 import { NonRetryableError, WorkflowEntrypointBase } from './bindings/workflow'
 import { getDatabase } from './db'
@@ -97,6 +98,21 @@ Object.defineProperty(globalThis.performance, 'timeOrigin', {
 	configurable: true,
 })
 
+// Register addEventListener shim for legacy service worker syntax
+// Workers that use addEventListener("fetch", handler) instead of export default { fetch }
+const _serviceWorkerHandlers: { fetch?: (event: any) => void } = {}
+
+Object.defineProperty(globalThis, 'addEventListener', {
+	value: (type: string, handler: (event: any) => void) => {
+		if (type === 'fetch') {
+			_serviceWorkerHandlers.fetch = handler
+		}
+	},
+	writable: false,
+	configurable: true,
+}) /** @internal Get the registered service worker fetch handler */
+;(globalThis as any).__lopata_sw_handlers = _serviceWorkerHandlers
+
 // Register scheduler.wait(ms) — await-able setTimeout alternative
 Object.defineProperty(globalThis, 'scheduler', {
 	value: {
@@ -186,14 +202,66 @@ async function readBodyLimited(r: Request | Response): Promise<string | null> {
 	}
 }
 
+/** Apply cf.image transform to a fetch response */
+async function applyCfImageTransform(response: Response, imageOpts: Record<string, unknown>): Promise<Response> {
+	const ct = response.headers.get('content-type') ?? ''
+	if (!ct.startsWith('image/') || !response.body) return response
+
+	const { ImagesBinding } = await import('./bindings/images')
+	const images = new ImagesBinding()
+
+	// Split cf.image options into transform options and output options
+	const { format: rawFormat, quality, compression, metadata, ...transformRest } = imageOpts
+	const transformer = images.input(response.body).transform(transformRest as ImageTransformOptions)
+
+	// Determine output format
+	let outputFormat: OutputOptions['format'] = ct as OutputOptions['format']
+	if (rawFormat && rawFormat !== 'auto') {
+		const shortToMime: Record<string, OutputOptions['format']> = {
+			avif: 'image/avif',
+			webp: 'image/webp',
+			jpeg: 'image/jpeg',
+			png: 'image/png',
+			gif: 'image/gif',
+		}
+		outputFormat = shortToMime[rawFormat as string] ?? outputFormat
+	}
+	// Fallback to a valid format if the source CT isn't in our supported set
+	if (!['image/png', 'image/jpeg', 'image/webp', 'image/avif', 'image/gif'].includes(outputFormat)) {
+		outputFormat = 'image/webp'
+	}
+
+	const outputOpts: OutputOptions = { format: outputFormat }
+	if (rawFormat === 'auto') {
+		// Pass format through transform-level auto detection
+		;(transformRest as ImageTransformOptions).format = 'auto'
+	}
+	if (quality !== undefined) outputOpts.quality = quality as OutputOptions['quality']
+	if (compression !== undefined) outputOpts.compression = compression as OutputOptions['compression']
+	if (metadata !== undefined) outputOpts.metadata = metadata as OutputOptions['metadata']
+
+	const result = await transformer.output(outputOpts)
+	const headers = new Headers(response.headers)
+	headers.set('content-type', result.contentType())
+	headers.delete('content-length') // size changed after transform
+	return new Response(result.image(), { status: response.status, statusText: response.statusText, headers })
+}
+
 const _originalFetch = globalThis.fetch
 globalThis.fetch = ((input: any, init?: any): Promise<Response> => {
 	const ctx = getActiveContext()
 	if (ctx) {
 		ctx.fetchStack.current = new Error()
 	}
-	// Outside a trace context, just pass through
-	if (!ctx) return _originalFetch(input, init)
+
+	// Extract cf.image options before creating request (Request constructor drops cf)
+	const cfImageOpts = init?.cf?.image as Record<string, unknown> | undefined
+
+	// Outside a trace context, handle cf.image without tracing
+	if (!ctx) {
+		const p = _originalFetch(input, init)
+		return cfImageOpts ? p.then(r => applyCfImageTransform(r, cfImageOpts)) : p
+	}
 
 	const request = new Request(input, init)
 	const fetchRequest = request.clone()
@@ -219,13 +287,18 @@ globalThis.fetch = ((input: any, init?: any): Promise<Response> => {
 		const reqBody = await readBodyLimited(request)
 		if (reqBody) setSpanAttribute('http.request.body', reqBody)
 
-		const response = await _originalFetch(fetchRequest as globalThis.Request)
+		let response = await _originalFetch(fetchRequest as globalThis.Request)
+
+		// Apply cf.image transform if present
+		if (cfImageOpts) {
+			response = await applyCfImageTransform(response, cfImageOpts)
+		}
 
 		setSpanAttribute('http.status_code', response.status)
 		setSpanAttribute('http.response.headers', headersToRecord(response.headers))
 
 		// Capture response body from a clone (caller keeps the original stream)
-		const resBody = await readBodyLimited(response.clone())
+		const resBody = await readBodyLimited(response.clone() as Response)
 		if (resBody) setSpanAttribute('http.response.body', resBody)
 
 		return response

package/src/request-cf.ts

@@ -15,6 +15,8 @@ const DEFAULT_CF: Record<string, unknown> = {
 	httpProtocol: 'HTTP/2',
 	tlsVersion: 'TLSv1.3',
 	tlsCipher: 'AEAD-AES128-GCM-SHA256',
+	isEUCountry: '0',
+	clientAcceptEncoding: 'gzip, deflate, br',
 }
 
 export function addCfProperty(request: Request): Request {

package/src/tracing/store.ts

@@ -210,7 +210,7 @@ export class TraceStore {
 
 		params.push(limit)
 
-		const rows = this.db.prepare<Record<string, unknown>, unknown[]>(`
+		const rows = this.db.prepare<Record<string, unknown>, any>(`
       SELECT
         s.trace_id,
         s.name as root_span_name,

package/src/tsconfig.json

@@ -3,6 +3,7 @@
 	"compilerOptions": {
 		"allowJs": true,
 		"composite": true,
+		"outDir": "../.tsc-out/src",
 
 		"noUnusedLocals": false,
 		"noUnusedParameters": false,

package/src/vite-plugin/dev-server-plugin.ts

@@ -467,7 +467,6 @@ function nodeReqToRequest(req: IncomingMessage): Request {
 		method,
 		headers,
 		body: hasBody ? nodeStreamToReadable(req) : undefined,
-		// @ts-expect-error duplex is needed for streaming request bodies
 		duplex: hasBody ? 'half' : undefined,
 	})
 }

package/src/warnings.ts

@@ -0,0 +1,30 @@
+export interface OptionalDep {
+	id: string
+	description: string
+	install: string
+	installed: boolean
+}
+
+function isAvailable(name: string): boolean {
+	try {
+		import.meta.resolve(name)
+		return true
+	} catch {
+		return false
+	}
+}
+
+const OPTIONAL_DEPS: { id: string; description: string; install: string }[] = [
+	{ id: 'html-rewriter-wasm', description: 'HTMLRewriter API', install: 'bun add html-rewriter-wasm' },
+	{ id: 'sharp', description: 'Image transformations', install: 'bun add sharp' },
+	{ id: 'puppeteer-core', description: 'Browser rendering', install: 'bun add puppeteer-core' },
+]
+
+const resolved: OptionalDep[] = OPTIONAL_DEPS.map(dep => ({
+	...dep,
+	installed: isAvailable(dep.id),
+}))
+
+export function getOptionalDeps(): OptionalDep[] {
+	return resolved
+}