lopata 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "lopata",
-	"version": "0.13.0",
+	"version": "0.14.0",
 	"type": "module",
 	"license": "MIT",
 	"repository": {

package/src/bindings/do-executor-inprocess.ts

@@ -45,24 +45,22 @@ export class InProcessExecutor implements DOExecutor {
 	}
 
 	async executeFetch(request: Request): Promise<Response> {
-		const unlock = await this._state._lock()
+		await this._state._enter()
 		try {
-			await this._state._waitForReady()
 			const fetchFn = (this._instance as unknown as Record<string, unknown>).fetch
 			if (typeof fetchFn !== 'function') {
 				throw new Error('Durable Object does not implement fetch()')
 			}
 			return await (fetchFn as (req: Request) => Promise<Response>).call(this._instance, request)
 		} finally {
-			unlock()
+			this._state._exit()
 		}
 	}
 
 	async executeRpc(method: string, args: unknown[]): Promise<unknown> {
 		warnInvalidRpcArgs(args, method)
-		const unlock = await this._state._lock()
+		await this._state._enter()
 		try {
-			await this._state._waitForReady()
 			const val = (this._instance as unknown as Record<string, unknown>)[method]
 			if (typeof val === 'function') {
 				const result = await (val as (...a: unknown[]) => unknown).call(this._instance, ...args)
@@ -70,28 +68,26 @@ export class InProcessExecutor implements DOExecutor {
 			}
 			throw new Error(`"${method}" is not a method on the Durable Object`)
 		} finally {
-			unlock()
+			this._state._exit()
 		}
 	}
 
 	async executeRpcGet(prop: string): Promise<unknown> {
-		const unlock = await this._state._lock()
+		await this._state._enter()
 		try {
-			await this._state._waitForReady()
 			const val = (this._instance as unknown as Record<string, unknown>)[prop]
 			if (typeof val === 'function') {
 				return createRpcFunctionStub(val as Function, this._instance)
 			}
 			return wrapRpcReturnValue(val, prop)
 		} finally {
-			unlock()
+			this._state._exit()
 		}
 	}
 
 	async executeAlarm(retryCount: number): Promise<void> {
-		const unlock = await this._state._lock()
+		await this._state._enter()
 		try {
-			await this._state._waitForReady()
 			const alarmFn = (this._instance as unknown as Record<string, unknown>).alarm
 			if (typeof alarmFn === 'function') {
 				await alarmFn.call(this._instance, {
@@ -100,7 +96,7 @@ export class InProcessExecutor implements DOExecutor {
 				})
 			}
 		} finally {
-			unlock()
+			this._state._exit()
 		}
 	}
 
@@ -120,7 +116,18 @@ export class InProcessExecutor implements DOExecutor {
 		return this._state._isAborted()
 	}
 
+	reloadClass(cls: new(ctx: DurableObjectStateImpl, env: unknown) => DurableObjectBase, env: unknown): void {
+		this._instance = new cls(this._state, env)
+		this._state._setInstanceResolver(() => this._instance)
+	}
+
 	async dispose(): Promise<void> {
+		// Close all accepted WebSockets so clients can reconnect to new instance
+		for (const ws of this._state.getWebSockets()) {
+			try {
+				ws.close(1012, 'Service restart')
+			} catch {}
+		}
 		if (this._containerRuntime) {
 			await this._containerRuntime.cleanup()
 		}

package/src/bindings/do-executor.ts

@@ -39,6 +39,9 @@ export interface DOExecutor {
 	/** Whether the instance has been aborted */
 	isAborted(): boolean
 
+	/** Hot-swap the DO class and env without disposing (preserves WebSocket connections) */
+	reloadClass?(cls: new(ctx: any, env: unknown) => DurableObjectBase, env: unknown): void
+
 	/** Kill the instance */
 	dispose(): Promise<void>
 }

package/src/bindings/do-worker-entry.ts

@@ -94,9 +94,8 @@ async function initWorker(workerConfig: WorkerConfig) {
 	async function handleCommand(cmd: DOCommand): Promise<DOResult> {
 		switch (cmd.type) {
 			case 'fetch': {
-				const unlock = await state._lock()
+				await state._enter()
 				try {
-					await state._waitForReady()
 					const fetchFn = (instance as any).fetch
 					if (typeof fetchFn !== 'function') {
 						throw new Error('Durable Object does not implement fetch()')
@@ -118,14 +117,13 @@ async function initWorker(workerConfig: WorkerConfig) {
 						body: resBody,
 					}
 				} finally {
-					unlock()
+					state._exit()
 				}
 			}
 
 			case 'rpc-call': {
-				const unlock = await state._lock()
+				await state._enter()
 				try {
-					await state._waitForReady()
 					const val = (instance as any)[cmd.method]
 					if (typeof val !== 'function') {
 						throw new Error(`"${cmd.method}" is not a method on the Durable Object`)
@@ -133,28 +131,26 @@ async function initWorker(workerConfig: WorkerConfig) {
 					const result = await val.call(instance, ...cmd.args)
 					return { type: 'rpc-call', value: result }
 				} finally {
-					unlock()
+					state._exit()
 				}
 			}
 
 			case 'rpc-get': {
-				const unlock = await state._lock()
+				await state._enter()
 				try {
-					await state._waitForReady()
 					const val = (instance as any)[cmd.prop]
 					if (typeof val === 'function') {
 						return { type: 'rpc-get', value: '__function__' }
 					}
 					return { type: 'rpc-get', value: val }
 				} finally {
-					unlock()
+					state._exit()
 				}
 			}
 
 			case 'alarm': {
-				const unlock = await state._lock()
+				await state._enter()
 				try {
-					await state._waitForReady()
 					const alarmFn = (instance as any).alarm
 					if (typeof alarmFn === 'function') {
 						await alarmFn.call(instance, {
@@ -164,7 +160,7 @@ async function initWorker(workerConfig: WorkerConfig) {
 					}
 					return { type: 'alarm' }
 				} finally {
-					unlock()
+					state._exit()
 				}
 			}
 

package/src/bindings/durable-object.ts

@@ -83,6 +83,24 @@ export class SqlStorageCursor implements Iterable<Record<string, unknown>> {
 	}
 }
 
+// --- DB-level transaction mutex ---
+// Shared across all SqliteDurableObjectStorage instances using the same Database connection.
+// Prevents overlapping BEGIN/COMMIT blocks from concurrent requests.
+const dbTxnLocks = new WeakMap<Database, Promise<void>>()
+
+async function acquireDbTxnLock(db: Database): Promise<() => void> {
+	let unlock!: () => void
+	const next = new Promise<void>((r) => {
+		unlock = r
+	})
+	const ready = dbTxnLocks.get(db) ?? Promise.resolve()
+	dbTxnLocks.set(db, next)
+	await ready
+	return () => {
+		unlock()
+	}
+}
+
 // --- SQL Storage API ---
 
 export class SqlStorage {
@@ -324,14 +342,15 @@ export class SqliteDurableObjectStorage {
 			const stmt = this.db.query(
 				'INSERT OR REPLACE INTO do_storage (namespace, id, key, value) VALUES (?, ?, ?, ?)',
 			)
-			this.db.run('BEGIN')
+			this.db.run('SAVEPOINT put_batch')
 			try {
 				for (const [k, v] of Object.entries(keyOrEntries)) {
 					stmt.run(this.namespace, this.id, k, JSON.stringify(v))
 				}
-				this.db.run('COMMIT')
+				this.db.run('RELEASE put_batch')
 			} catch (e) {
-				this.db.run('ROLLBACK')
+				this.db.run('ROLLBACK TO put_batch')
+				this.db.run('RELEASE put_batch')
 				throw e
 			}
 		}
@@ -415,14 +434,19 @@ export class SqliteDurableObjectStorage {
 	}
 
 	async transaction<T>(closure: (txn: SqliteDurableObjectStorage) => Promise<T>): Promise<T> {
-		this.db.run('BEGIN')
+		const unlock = await acquireDbTxnLock(this.db)
 		try {
-			const result = await closure(this)
-			this.db.run('COMMIT')
-			return result
-		} catch (e) {
-			this.db.run('ROLLBACK')
-			throw e
+			this.db.run('BEGIN')
+			try {
+				const result = await closure(this)
+				this.db.run('COMMIT')
+				return result
+			} catch (e) {
+				this.db.run('ROLLBACK')
+				throw e
+			}
+		} finally {
+			unlock()
 		}
 	}
 
@@ -506,7 +530,6 @@ export class DurableObjectStateImpl {
 	private _hibernatableTimeout: number | null = null
 	private _limits: Required<DurableObjectLimits>
 	private _instanceResolver: (() => DurableObjectBase | null) | null = null
-	private _lockTail: Promise<void> = Promise.resolve()
 	private _activeRequests = 0
 	private _aborted = false
 	private _abortReason: string | undefined
@@ -545,27 +568,21 @@ export class DurableObjectStateImpl {
 		return this._activeRequests > 0
 	}
 
-	/** @internal Acquire the serial-execution lock. Caller awaits this, then runs work in its own async stack. */
-	async _lock(): Promise<() => void> {
+	/** @internal Enter a request — waits for blockConcurrencyWhile, checks abort, increments counter. */
+	async _enter(): Promise<void> {
 		if (this._aborted) {
 			throw new Error(this._abortReason ?? 'Durable Object has been aborted')
 		}
-		let unlockNext: () => void
-		const nextTail = new Promise<void>(r => {
-			unlockNext = r
-		})
-		const ready = this._lockTail
-		this._lockTail = nextTail
-		await ready
+		await this._waitForReady()
 		if (this._aborted) {
-			unlockNext!()
 			throw new Error(this._abortReason ?? 'Durable Object has been aborted')
 		}
 		this._activeRequests++
-		return () => {
-			this._activeRequests--
-			unlockNext!()
-		}
+	}
+
+	/** @internal Exit a request — decrements counter. */
+	_exit(): void {
+		this._activeRequests--
 	}
 
 	/**
@@ -776,9 +793,11 @@ export class DurableObjectNamespaceImpl {
 
 	/** Called after worker module is loaded to wire the actual class */
 	_setClass(cls: new(ctx: DurableObjectStateImpl, env: unknown) => DurableObjectBase, env: unknown, generationId?: number) {
-		// Dispose existing executors so next request creates new ones with the new class
 		for (const [idStr, executor] of this._executors) {
-			if (executor.activeWebSocketCount() === 0) {
+			if (executor.activeWebSocketCount() > 0 && executor.reloadClass) {
+				// Hot-swap: reuse state + WebSocket connections, create new instance with new code
+				executor.reloadClass(cls, env)
+			} else {
 				executor.dispose().catch(() => {})
 				this._executors.delete(idStr)
 				this._lastActivity.delete(idStr)

package/src/bindings/media.ts

@@ -0,0 +1,320 @@
+// Media Transformations binding — ffmpeg-based implementation for local dev
+// Cloudflare's Media binding provides video/audio processing (resize, crop, frame extraction, etc.)
+// Requires ffmpeg installed on the system. Falls back to passthrough if unavailable.
+//
+// Note: MP4 files often have the moov atom at the end, making them non-streamable.
+// ffmpeg needs to seek backwards to read the moov atom, which doesn't work with stdin pipes.
+// We use temp files for input/output to handle all container formats correctly.
+
+import { randomUUID } from 'node:crypto'
+import { unlink } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+export interface MediaTransformOptions {
+	width?: number
+	height?: number
+	fit?: 'contain' | 'cover' | 'crop' | 'scale-down'
+	trim?: { start?: string; end?: string }
+}
+
+export interface MediaOutputOptions {
+	mode: 'video' | 'frame' | 'spritesheet' | 'audio'
+	duration?: string
+	offset?: string
+	format?: string
+	fps?: number
+	columns?: number
+	rows?: number
+}
+
+export interface MediaOutputResult {
+	response(): Promise<Response>
+}
+
+// --- Lazy ffmpeg detection ---
+
+let _ffmpegResolved = false
+let _ffmpegAvailable = false
+let _ffmpegWarned = false
+
+async function hasFfmpeg(): Promise<boolean> {
+	if (!_ffmpegResolved) {
+		try {
+			const proc = Bun.spawn(['ffmpeg', '-version'], { stdout: 'ignore', stderr: 'ignore' })
+			const code = await proc.exited
+			_ffmpegAvailable = code === 0
+		} catch {
+			_ffmpegAvailable = false
+		}
+		_ffmpegResolved = true
+	}
+	return _ffmpegAvailable
+}
+
+function warnFfmpegMissing() {
+	if (!_ffmpegWarned) {
+		console.warn('[lopata] ffmpeg is not installed — media transformations will pass through unchanged. Install it: https://ffmpeg.org')
+		_ffmpegWarned = true
+	}
+}
+
+// --- Content type helpers ---
+
+const MODE_CONTENT_TYPES: Record<string, Record<string, string>> = {
+	video: { mp4: 'video/mp4', webm: 'video/webm' },
+	frame: { png: 'image/png', jpeg: 'image/jpeg', jpg: 'image/jpeg', webp: 'image/webp' },
+	spritesheet: { png: 'image/png', jpeg: 'image/jpeg', jpg: 'image/jpeg', webp: 'image/webp' },
+	audio: { m4a: 'audio/mp4', mp3: 'audio/mpeg', ogg: 'audio/ogg' },
+}
+
+const MODE_DEFAULTS: Record<string, { format: string; contentType: string }> = {
+	video: { format: 'mp4', contentType: 'video/mp4' },
+	frame: { format: 'png', contentType: 'image/png' },
+	spritesheet: { format: 'png', contentType: 'image/png' },
+	audio: { format: 'm4a', contentType: 'audio/mp4' },
+}
+
+function resolveContentType(mode: string, format?: string): { ffFormat: string; contentType: string } {
+	const defaults = MODE_DEFAULTS[mode] ?? MODE_DEFAULTS.video!
+	if (!format) return { ffFormat: defaults.format, contentType: defaults.contentType }
+	const ct = MODE_CONTENT_TYPES[mode]?.[format]
+	return { ffFormat: format, contentType: ct ?? defaults.contentType }
+}
+
+// --- ffmpeg argument builders ---
+
+function buildScaleFilter(transforms: MediaTransformOptions[]): string | null {
+	// Use the last transform that specifies dimensions
+	for (let i = transforms.length - 1; i >= 0; i--) {
+		const t = transforms[i]!
+		if (t.width || t.height) {
+			const w = t.width ?? -2
+			const h = t.height ?? -2
+			const fit = t.fit ?? 'contain'
+
+			if (fit === 'contain' || fit === 'scale-down') {
+				// Scale to fit within dimensions, preserving aspect ratio
+				return `scale=${w}:${h}:force_original_aspect_ratio=decrease`
+			} else if (fit === 'cover' || fit === 'crop') {
+				// Scale to cover, then crop to exact dimensions
+				if (t.width && t.height) {
+					return `scale=${t.width}:${t.height}:force_original_aspect_ratio=increase,crop=${t.width}:${t.height}`
+				}
+				return `scale=${w}:${h}:force_original_aspect_ratio=increase`
+			}
+			return `scale=${w}:${h}`
+		}
+	}
+	return null
+}
+
+function buildTrimArgs(transforms: MediaTransformOptions[], outputOpts: MediaOutputOptions): string[] {
+	const args: string[] = []
+
+	// Seek from transform trim or output offset
+	for (const t of transforms) {
+		if (t.trim?.start) {
+			args.push('-ss', t.trim.start)
+			break
+		}
+	}
+	if (args.length === 0 && outputOpts.offset) {
+		args.push('-ss', outputOpts.offset)
+	}
+
+	// End time from transform trim
+	for (const t of transforms) {
+		if (t.trim?.end) {
+			args.push('-to', t.trim.end)
+			break
+		}
+	}
+
+	// Duration from output options
+	if (outputOpts.duration) {
+		args.push('-t', outputOpts.duration)
+	}
+
+	return args
+}
+
+function buildVideoArgs(transforms: MediaTransformOptions[], opts: MediaOutputOptions): string[] {
+	const args: string[] = []
+
+	args.push(...buildTrimArgs(transforms, opts))
+
+	const scale = buildScaleFilter(transforms)
+	if (scale) args.push('-vf', scale)
+
+	args.push('-movflags', '+faststart')
+
+	return args
+}
+
+function buildFrameArgs(transforms: MediaTransformOptions[], opts: MediaOutputOptions): string[] {
+	const args: string[] = []
+
+	if (opts.offset) args.push('-ss', opts.offset)
+
+	args.push('-frames:v', '1')
+
+	const scale = buildScaleFilter(transforms)
+	if (scale) args.push('-vf', scale)
+
+	return args
+}
+
+function buildSpritesheetArgs(transforms: MediaTransformOptions[], opts: MediaOutputOptions): string[] {
+	const args: string[] = []
+
+	args.push(...buildTrimArgs(transforms, opts))
+
+	const fps = opts.fps ?? 1
+	const columns = opts.columns ?? 5
+	const rows = opts.rows ?? 4
+
+	const filters: string[] = []
+	filters.push(`fps=${fps}`)
+
+	const scale = buildScaleFilter(transforms)
+	if (scale) filters.push(scale)
+
+	filters.push(`tile=${columns}x${rows}`)
+
+	args.push('-vf', filters.join(','))
+	args.push('-frames:v', '1')
+
+	return args
+}
+
+function buildAudioArgs(transforms: MediaTransformOptions[], opts: MediaOutputOptions): string[] {
+	const args: string[] = []
+	const { ffFormat } = resolveContentType('audio', opts.format)
+
+	args.push(...buildTrimArgs(transforms, opts))
+
+	args.push('-vn') // no video
+
+	// m4a extension is recognized by ffmpeg, no explicit format needed
+	const codecMap: Record<string, string[]> = {
+		ogg: ['-c:a', 'libvorbis'],
+	}
+	if (codecMap[ffFormat]) args.push(...codecMap[ffFormat]!)
+
+	return args
+}
+
+// --- Passthrough (no ffmpeg) ---
+
+async function readStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array> {
+	const reader = stream.getReader()
+	const chunks: Uint8Array[] = []
+	let totalLength = 0
+	while (true) {
+		const { done, value } = await reader.read()
+		if (done) break
+		chunks.push(value)
+		totalLength += value.byteLength
+	}
+	const result = new Uint8Array(totalLength)
+	let offset = 0
+	for (const chunk of chunks) {
+		result.set(chunk, offset)
+		offset += chunk.byteLength
+	}
+	return result
+}
+
+// --- MediaTransformer ---
+
+class MediaTransformer {
+	private streamPromise: Promise<Uint8Array>
+	private transforms: MediaTransformOptions[] = []
+
+	constructor(stream: ReadableStream<Uint8Array>) {
+		this.streamPromise = readStream(stream)
+	}
+
+	transform(options: MediaTransformOptions): MediaTransformer {
+		this.transforms.push(options)
+		return this
+	}
+
+	output(opts: MediaOutputOptions): MediaOutputResult {
+		const transforms = this.transforms
+		const streamPromise = this.streamPromise
+
+		return {
+			async response(): Promise<Response> {
+				if (!(await hasFfmpeg())) {
+					warnFfmpegMissing()
+					const buf = await streamPromise
+					return new Response(buf, {
+						headers: { 'content-type': 'application/octet-stream' },
+					})
+				}
+
+				const { contentType } = resolveContentType(opts.mode, opts.format)
+
+				let modeArgs: string[]
+				switch (opts.mode) {
+					case 'video':
+						modeArgs = buildVideoArgs(transforms, opts)
+						break
+					case 'frame':
+						modeArgs = buildFrameArgs(transforms, opts)
+						break
+					case 'spritesheet':
+						modeArgs = buildSpritesheetArgs(transforms, opts)
+						break
+					case 'audio':
+						modeArgs = buildAudioArgs(transforms, opts)
+						break
+				}
+
+				const inputBuf = await streamPromise
+
+				// Use temp files — MP4 moov atom is often at EOF, requiring seek (stdin pipes can't seek)
+				const { ffFormat } = resolveContentType(opts.mode, opts.format)
+				const id = randomUUID()
+				const inputPath = join(tmpdir(), `lopata-media-in-${id}`)
+				const outputPath = join(tmpdir(), `lopata-media-out-${id}.${ffFormat}`)
+
+				try {
+					await Bun.write(inputPath, inputBuf)
+
+					const proc = Bun.spawn(
+						['ffmpeg', '-hide_banner', '-loglevel', 'error', '-y', '-i', inputPath, ...modeArgs, outputPath],
+						{ stdout: 'pipe', stderr: 'pipe' },
+					)
+
+					const [stderrBuf, exitCode] = await Promise.all([
+						new Response(proc.stderr).text(),
+						proc.exited,
+					])
+
+					if (exitCode !== 0) {
+						throw new Error(`[lopata] ffmpeg failed (exit ${exitCode}): ${stderrBuf.trim()}`)
+					}
+
+					const output = await Bun.file(outputPath).arrayBuffer()
+					return new Response(output, {
+						headers: { 'content-type': contentType },
+					})
+				} finally {
+					unlink(inputPath).catch(() => {})
+					unlink(outputPath).catch(() => {})
+				}
+			},
+		}
+	}
+}
+
+// --- MediaBinding ---
+
+export class MediaBinding {
+	input(stream: ReadableStream<Uint8Array>): MediaTransformer {
+		return new MediaTransformer(stream)
+	}
+}

package/src/cli/cache.ts

@@ -1,11 +1,12 @@
 import type { CliContext } from './context'
-import { parseFlag } from './context'
+import { parseArgs } from './context'
 
 export async function run(ctx: CliContext, args: string[]) {
 	const action = args[0]
 
 	switch (action) {
 		case 'list': {
+			parseArgs(args.slice(1), {})
 			const db = ctx.db()
 			const rows = db.query<{ cache_name: string; cnt: number }, []>(
 				'SELECT cache_name, COUNT(*) as cnt FROM cache_entries GROUP BY cache_name ORDER BY cache_name',
@@ -20,12 +21,14 @@ export async function run(ctx: CliContext, args: string[]) {
 			break
 		}
 		case 'purge': {
-			const cacheName = parseFlag(ctx.args, '--name')
+			const { values } = parseArgs(args.slice(1), {
+				name: { type: 'string' },
+			})
 			const db = ctx.db()
 			let result: { changes: number }
-			if (cacheName) {
-				result = db.run('DELETE FROM cache_entries WHERE cache_name = ?', [cacheName])
-				console.log(`Purged ${result.changes} entries from cache "${cacheName}"`)
+			if (values.name) {
+				result = db.run('DELETE FROM cache_entries WHERE cache_name = ?', [values.name])
+				console.log(`Purged ${result.changes} entries from cache "${values.name}"`)
 			} else {
 				result = db.run('DELETE FROM cache_entries')
 				console.log(`Purged ${result.changes} cache entries (all caches)`)