lopata 0.3.1 → 0.4.1

package/dist/error-page.html

@@ -20,6 +20,8 @@
     --color-red-50: oklch(97.1% .013 17.38);
     --color-red-300: oklch(80.8% .114 19.571);
     --color-red-400: oklch(70.4% .191 22.216);
+    --color-amber-400: oklch(82.8% .189 84.429);
+    --color-amber-600: oklch(66.6% .179 58.318);
     --color-emerald-400: oklch(76.5% .177 163.223);
     --color-gray-50: oklch(98.5% .002 247.839);
     --color-gray-100: oklch(96.7% .003 264.542);
@@ -412,6 +414,10 @@
     margin-right: calc(var(--spacing) * 2);
   }
 
+  .mb-1 {
+    margin-bottom: calc(var(--spacing) * 1);
+  }
+
   .mb-1\.5 {
     margin-bottom: calc(var(--spacing) * 1.5);
   }
@@ -592,6 +598,10 @@
     border-color: #0000;
   }
 
+  .border-l-amber-400 {
+    border-left-color: var(--color-amber-400);
+  }
+
   .border-l-error-red {
     border-left-color: var(--color-error-red);
   }
@@ -761,6 +771,10 @@
     white-space: pre-wrap;
   }
 
+  .text-amber-600 {
+    color: var(--color-amber-600);
+  }
+
   .text-error-red {
     color: var(--color-error-red);
   }
@@ -1774,6 +1788,39 @@ function App() {
           frames: error.frames
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
+      error.causes?.map((cause, i3) => /* @__PURE__ */ u3("div", {
+        class: "flex flex-col gap-4",
+        children: [
+          /* @__PURE__ */ u3("div", {
+            class: "bg-white rounded-lg border border-gray-200 overflow-hidden border-l-4 border-l-amber-400",
+            children: /* @__PURE__ */ u3("div", {
+              class: "px-5 py-3",
+              children: [
+                /* @__PURE__ */ u3("div", {
+                  class: "flex items-center gap-2.5 mb-1",
+                  children: /* @__PURE__ */ u3("span", {
+                    class: "text-xs font-semibold uppercase tracking-wider text-amber-600",
+                    children: [
+                      "Caused by: ",
+                      cause.name
+                    ]
+                  }, undefined, true, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ u3(ErrorMessage, {
+                  message: cause.message
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          cause.frames.length > 0 && /* @__PURE__ */ u3(Section, {
+            title: `Source Code (cause ${i3 + 1})`,
+            open: true,
+            children: /* @__PURE__ */ u3(FrameList, {
+              frames: cause.frames
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, i3, true, undefined, this)),
       /* @__PURE__ */ u3(Section, {
         title: "Stack Trace",
         children: /* @__PURE__ */ u3("div", {
@@ -1781,8 +1828,22 @@ function App() {
           children: /* @__PURE__ */ u3("pre", {
             class: "text-xs text-ink-muted leading-5 m-0 whitespace-pre-wrap break-words",
             style: "font-family: 'JetBrains Mono', monospace;",
-            children: error.stack
-          }, undefined, false, undefined, this)
+            children: [
+              error.stack,
+              error.causes?.map((cause, i3) => /* @__PURE__ */ u3("span", {
+                children: [
+                  `
+
+`,
+                  /* @__PURE__ */ u3("span", {
+                    class: "text-amber-600 font-semibold",
+                    children: "[cause]: "
+                  }, undefined, false, undefined, this),
+                  cause.stack
+                ]
+              }, i3, true, undefined, this))
+            ]
+          }, undefined, true, undefined, this)
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
       data.trace && data.trace.spans.length > 0 && /* @__PURE__ */ u3(Section, {

package/package.json

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

package/src/bindings/crypto-extras.ts

@@ -68,6 +68,82 @@ export class DigestStream extends WritableStream<ArrayBuffer | ArrayBufferView>
 	}
 }
 
+/**
+ * Detect if DER-encoded key data is PKCS#1 RSAPrivateKey format.
+ * PKCS#1: SEQUENCE { INTEGER(version=0), INTEGER(modulus), ... }
+ * PKCS#8: SEQUENCE { INTEGER(version=0), SEQUENCE(algorithmId), ... }
+ */
+function isPkcs1RsaKey(data: Uint8Array): boolean {
+	if (data.length < 10 || data[0] !== 0x30) return false
+	let offset = 1
+	// Skip outer SEQUENCE length
+	if (data[offset]! & 0x80) {
+		offset += 1 + (data[offset]! & 0x7f)
+	} else {
+		offset += 1
+	}
+	// Expect version: INTEGER 0 (02 01 00)
+	if (data[offset] !== 0x02 || data[offset + 1] !== 0x01 || data[offset + 2] !== 0x00) return false
+	offset += 3
+	// PKCS#1 next element is INTEGER (0x02 = modulus)
+	// PKCS#8 next element is SEQUENCE (0x30 = algorithmIdentifier)
+	return data[offset] === 0x02
+}
+
+function derEncodeLength(length: number): Uint8Array {
+	if (length < 0x80) return new Uint8Array([length])
+	if (length < 0x100) return new Uint8Array([0x81, length])
+	return new Uint8Array([0x82, (length >> 8) & 0xff, length & 0xff])
+}
+
+function derWrap(tag: number, content: Uint8Array): Uint8Array {
+	const len = derEncodeLength(content.length)
+	const result = new Uint8Array(1 + len.length + content.length)
+	result[0] = tag
+	result.set(len, 1)
+	result.set(content, 1 + len.length)
+	return result
+}
+
+/**
+ * Wrap a PKCS#1 RSAPrivateKey in a PKCS#8 PrivateKeyInfo envelope.
+ */
+function wrapPkcs1InPkcs8(pkcs1Key: Uint8Array): Uint8Array {
+	// AlgorithmIdentifier: SEQUENCE { OID 1.2.840.113549.1.1.1 (rsaEncryption), NULL }
+	const rsaAlgorithmId = new Uint8Array([
+		0x30,
+		0x0d,
+		0x06,
+		0x09,
+		0x2a,
+		0x86,
+		0x48,
+		0x86,
+		0xf7,
+		0x0d,
+		0x01,
+		0x01,
+		0x01,
+		0x05,
+		0x00,
+	])
+	const version = new Uint8Array([0x02, 0x01, 0x00])
+	const privateKeyOctetString = derWrap(0x04, pkcs1Key)
+
+	const inner = new Uint8Array(version.length + rsaAlgorithmId.length + privateKeyOctetString.length)
+	inner.set(version, 0)
+	inner.set(rsaAlgorithmId, version.length)
+	inner.set(privateKeyOctetString, version.length + rsaAlgorithmId.length)
+
+	return derWrap(0x30, inner)
+}
+
+function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array {
+	if (data instanceof Uint8Array) return data
+	if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+	return new Uint8Array(data)
+}
+
 /**
  * Patches the global `crypto` object with CF-specific extensions.
  */
@@ -86,4 +162,17 @@ export function patchGlobalCrypto(): void {
 		writable: false,
 		configurable: true,
 	})
+
+	// Patch importKey to accept PKCS#1 RSA keys with "pkcs8" format (matching workerd behavior).
+	// Workerd is lenient and auto-wraps PKCS#1 in PKCS#8; Bun/Node native crypto rejects it.
+	const origImportKey = subtle.importKey.bind(subtle)
+	subtle.importKey = ((format: string, keyData: unknown, algorithm: unknown, extractable: boolean, keyUsages: readonly string[]) => {
+		if (format === 'pkcs8' && typeof keyData === 'object' && keyData !== null && !('kty' in keyData)) {
+			const bytes = toUint8Array(keyData as ArrayBuffer | ArrayBufferView)
+			if (isPkcs1RsaKey(bytes)) {
+				return (origImportKey as any)('pkcs8', wrapPkcs1InPkcs8(bytes), algorithm, extractable, [...keyUsages])
+			}
+		}
+		return (origImportKey as any)(format, keyData, algorithm, extractable, [...keyUsages])
+	}) as typeof subtle.importKey
 }

package/src/bindings/durable-object.ts

@@ -899,14 +899,19 @@ export class DurableObjectNamespaceImpl {
 		}
 	}
 
+	/** @internal Clear all in-memory alarm timers (alarms persist in DB for new generation to restore) */
+	clearAlarmTimers(): void {
+		for (const timer of this.alarmTimers.values()) clearTimeout(timer)
+		this.alarmTimers.clear()
+	}
+
 	/** @internal Destroy this namespace: clear timers, evict executors without active WebSockets */
 	destroy(): void {
 		if (this._evictionTimer) {
 			clearInterval(this._evictionTimer)
 			this._evictionTimer = null
 		}
-		for (const timer of this.alarmTimers.values()) clearTimeout(timer)
-		this.alarmTimers.clear()
+		this.clearAlarmTimers()
 		// Dispose executors without active WebSockets; keep the rest alive
 		for (const [idStr, executor] of this._executors) {
 			if (executor.activeWebSocketCount() === 0) {

package/src/error-page-render.ts

@@ -5,12 +5,20 @@ import { getActiveContext } from './tracing/context'
 import { enrichFrameWithSourceAsync, parseStackFrames, type StackFrame } from './tracing/frames'
 import { getTraceStore } from './tracing/store'
 
+interface ErrorCause {
+	name: string
+	message: string
+	stack: string
+	frames: StackFrame[]
+}
+
 interface ErrorPageData {
 	error: {
 		name: string
 		message: string
 		stack: string
 		frames: StackFrame[]
+		causes: ErrorCause[]
 	}
 	request: {
 		method: string
@@ -154,20 +162,36 @@ export async function renderErrorPage(
 	}
 
 	const err = error instanceof Error ? error : new Error(String(error))
-	const frames = parseStackFrames(err.stack ?? '')
-		// Drop native/node internal frames — they have no readable source and waste enrichment slots
-		.filter(f => !f.file.startsWith('native:') && !f.file.startsWith('node:'))
+	const cwdPrefix = process.cwd() + '/'
 
-	// Enrich frames with source code (limit to 20 for performance)
-	const framesToEnrich = frames.slice(0, 20)
-	await Promise.all(framesToEnrich.map(enrichFrameWithSourceAsync))
+	async function processError(e: Error): Promise<{ frames: StackFrame[]; stack: string }> {
+		const frames = parseStackFrames(e.stack ?? '')
+			.filter(f => !f.file.startsWith('native:') && !f.file.startsWith('node:'))
+		const framesToEnrich = frames.slice(0, 20)
+		await Promise.all(framesToEnrich.map(enrichFrameWithSourceAsync))
+		const displayFrames = framesToEnrich.filter(f => f.source).map(f => ({
+			...f,
+			file: f.file.startsWith(cwdPrefix) ? f.file.slice(cwdPrefix.length) : f.file,
+		}))
+		return { frames: displayFrames, stack: e.stack ?? String(e) }
+	}
 
-	// Strip cwd prefix from paths for display
-	const cwdPrefix = process.cwd() + '/'
-	const displayFrames = framesToEnrich.filter(f => f.source).map(f => ({
-		...f,
-		file: f.file.startsWith(cwdPrefix) ? f.file.slice(cwdPrefix.length) : f.file,
-	}))
+	const { frames: displayFrames, stack: mainStack } = await processError(err)
+
+	// Walk the cause chain
+	const causes: ErrorCause[] = []
+	let current: unknown = err.cause
+	for (let i = 0; i < 5 && current; i++) {
+		const causeErr = current instanceof Error ? current : new Error(String(current))
+		const { frames: causeFrames, stack: causeStack } = await processError(causeErr)
+		causes.push({
+			name: causeErr.name,
+			message: causeErr.message,
+			stack: causeStack,
+			frames: causeFrames,
+		})
+		current = causeErr.cause
+	}
 
 	const headers: Record<string, string> = {}
 	request.headers.forEach((value, key) => {
@@ -178,8 +202,9 @@ export async function renderErrorPage(
 		error: {
 			name: err.name,
 			message: err.message,
-			stack: err.stack ?? String(error),
+			stack: mainStack,
 			frames: displayFrames,
+			causes,
 		},
 		request: {
 			method: request.method,

package/src/generation-manager.ts

@@ -195,10 +195,20 @@ export class GenerationManager {
 			const oldGen = this.generations.get(oldGenId)
 			if (oldGen && oldGen.state === 'active') {
 				oldGen.drain()
-				// Schedule force-stop after grace period
-				oldGen.drainTimer = setTimeout(() => {
+				if (oldGen.isIdle()) {
+					// No in-flight work — stop immediately
 					this._stopGeneration(oldGenId)
-				}, this.gracePeriodMs)
+				} else {
+					// Poll for idle state, with grace period as hard maximum
+					oldGen.drainPollTimer = setInterval(() => {
+						if (oldGen.isIdle()) {
+							this._stopGeneration(oldGenId)
+						}
+					}, 200)
+					oldGen.drainTimer = setTimeout(() => {
+						this._stopGeneration(oldGenId)
+					}, this.gracePeriodMs)
+				}
 			}
 		}
 

package/src/generation.ts

@@ -55,6 +55,7 @@ export class Generation {
 	private queueConsumers: QueueConsumer[] = []
 	private cronTimer: NodeJS.Timer | ReturnType<typeof setInterval> | null = null
 	drainTimer: ReturnType<typeof setTimeout> | null = null
+	drainPollTimer: ReturnType<typeof setInterval> | null = null
 
 	constructor(
 		id: number,
@@ -350,11 +351,15 @@ export class Generation {
 		}
 	}
 
-	/** Transition to draining — stops consumers, keeps in-flight requests alive */
+	/** Transition to draining — stops consumers, clears alarm timers, keeps in-flight requests alive */
 	drain(): void {
 		if (this.state === 'stopped') return
 		this.state = 'draining'
 		this.stopConsumers()
+		// Clear alarm timers — new generation restores them from DB via _restoreAlarms()
+		for (const entry of this.registry.durableObjects) {
+			entry.namespace.clearAlarmTimers()
+		}
 	}
 
 	/** Force-stop: drain + destroy all DO namespaces + abort workflows */
@@ -366,6 +371,10 @@ export class Generation {
 			clearTimeout(this.drainTimer)
 			this.drainTimer = null
 		}
+		if (this.drainPollTimer) {
+			clearInterval(this.drainPollTimer)
+			this.drainPollTimer = null
+		}
 		for (const entry of this.registry.durableObjects) {
 			entry.namespace.destroy()
 		}

package/src/tracing/frames.ts

@@ -9,12 +9,16 @@ export interface StackFrame {
 	sourceLine?: number
 }
 
-const STACK_LINE_RE = /at\s+(?:(.+?)\s+\()?(.+):(\d+):(\d+)\)?/
+// V8: `at functionName (file:line:col)` or `at file:line:col`
+const V8_STACK_RE = /at\s+(?:(.+?)\s+\()?(.+):(\d+):(\d+)\)?/
+// JSC/Bun: `functionName@file:line:col`
+const JSC_STACK_RE = /^(.+?)@(.+):(\d+):(\d+)$/
 
 export function parseStackFrames(stack: string): StackFrame[] {
 	const frames: StackFrame[] = []
 	for (const line of stack.split('\n')) {
-		const match = line.match(STACK_LINE_RE)
+		const trimmed = line.trim()
+		const match = trimmed.match(V8_STACK_RE) ?? trimmed.match(JSC_STACK_RE)
 		if (!match) continue
 		frames.push({
 			file: match[2]!,

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

@@ -50,6 +50,8 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 
 	// Track current module to detect when Vite HMR invalidates it
 	let currentModule: Record<string, unknown> | null = null
+	// Serializes module reload — prevents concurrent wireClassRefs calls
+	let reloadLock: Promise<void> | null = null
 
 	return {
 		name: 'lopata:dev-server',
@@ -219,27 +221,43 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 						}
 
 						const entrypoint = resolve(server.config.root, config.main)
+
+						// Wait for any in-progress reload before importing
+						if (reloadLock) await reloadLock
+
 						const workerModule = await (ssrEnv as any).runner.import(entrypoint) as Record<string, unknown>
 
 						// Re-wire class refs when module changes (HMR invalidation)
 						if (workerModule !== currentModule) {
-							currentModule = workerModule
-
-							// Invalidate virtual modules in SSR environment.
-							// Framework plugins (e.g. React Router) may only invalidate
-							// virtual modules in the client module graph during HMR,
-							// leaving stale versions in the SSR environment.
-							invalidateVirtualModules(ssrEnv)
-
-							wireClassRefs(registry, workerModule, env, workerRegistry)
-							setGlobalEnv(env)
-							console.log('[lopata:vite] Worker module (re)loaded, classes wired')
+							if (reloadLock) {
+								// Another request started reloading while we were importing — wait for it
+								await reloadLock
+							} else {
+								let resolveReload!: () => void
+								reloadLock = new Promise(r => {
+									resolveReload = r
+								})
+								try {
+									currentModule = workerModule
+									wireClassRefs(registry, workerModule, env, workerRegistry)
+									setGlobalEnv(env)
+									console.log('[lopata:vite] Worker module (re)loaded, classes wired')
+								} catch (err) {
+									// Reset so next request retries
+									currentModule = null
+									throw err
+								} finally {
+									reloadLock = null
+									resolveReload()
+								}
+							}
 						}
 
 						const request = nodeReqToRequest(req)
 						const parsedUrl = new URL(request.url)
 
-						const handler = workerModule.default as Record<string, unknown>
+						const activeModule = currentModule ?? workerModule
+						const handler = activeModule.default as Record<string, unknown>
 						if (!handler || typeof handler.fetch !== 'function') {
 							console.error('[lopata:vite] Worker module default export has no fetch() method')
 							return next()
@@ -258,6 +276,18 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 								try {
 									const resp = await (handler.fetch as Function).call(handler, request, env, ctx) as Response
 									;(setSpanAttribute as Function)('http.status_code', resp.status)
+
+									// Intercept React Router error boundary responses with lopata error page
+									const routeError = (globalThis as any).__lopata_routeError
+									delete (globalThis as any).__lopata_routeError
+									if (routeError) {
+										if (routeError instanceof Error) {
+											stitchAsyncStack(routeError, callerStack)
+										}
+										console.error('[lopata:vite] Route error:\n' + (routeError instanceof Error ? routeError.stack : String(routeError)))
+										return (renderErrorPage as Function)(routeError, request, env, config)
+									}
+
 									ctx._awaitAll().catch(() => {})
 									return resp
 								} catch (err) {
@@ -390,36 +420,6 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	}
 }
 
-function invalidateVirtualModules(ssrEnv: any): void {
-	// Only invalidate Lopata's own virtual modules, NOT framework modules
-	// (e.g. React Router's virtual:react-router/server-manifest uses
-	// Math.random() for dev version — invalidating it generates a new version
-	// that mismatches the client's cached manifest, causing
-	// "manifest version mismatch during eager route discovery" errors).
-	const isLopataModule = (id: string) => id.includes('\0cloudflare:') || id.includes('\0@cloudflare/')
-
-	// Server-side: clear transformResult so fetchModule returns fresh code
-	const modGraph = ssrEnv.moduleGraph
-	if (modGraph?.idToModuleMap) {
-		for (const [id, mod] of modGraph.idToModuleMap) {
-			if (isLopataModule(id)) {
-				modGraph.invalidateModule(mod)
-			}
-		}
-	}
-
-	// Runner-side: clear evaluated state so next import re-evaluates
-	const runner = ssrEnv.runner
-	const evaluatedModules = runner?.evaluatedModules
-	if (evaluatedModules?.idToModuleMap) {
-		for (const [id, node] of evaluatedModules.idToModuleMap) {
-			if (isLopataModule(id)) {
-				evaluatedModules.invalidateModule(node)
-			}
-		}
-	}
-}
-
 function stitchAsyncStack(err: Error, callerError: Error | null): void {
 	if (!callerError) return
 	if (!err.stack || !callerError.stack) return

package/src/vite-plugin/react-router-plugin.ts

@@ -46,7 +46,7 @@ const __bf_instr = {
           },
         }, async () => {
           const result = await callHandler();
-          if (result.status === "error") throw result.error;
+          if (result.status === "error") { globalThis.__lopata_routeError = result.error; throw result.error; }
         });
       },
       action: async (callHandler, info) => {
@@ -62,7 +62,7 @@ const __bf_instr = {
           },
         }, async () => {
           const result = await callHandler();
-          if (result.status === "error") throw result.error;
+          if (result.status === "error") { globalThis.__lopata_routeError = result.error; throw result.error; }
         });
       },
     });