lopata 0.5.0 → 0.5.2

package/package.json

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

package/src/config.ts

@@ -80,8 +80,7 @@ export async function loadConfig(path: string, envName?: string): Promise<Wrangl
 	if (path.endsWith('.toml')) {
 		config = parseTOML(raw) as unknown as WranglerConfig
 	} else {
-		// JSON or JSONC — strip single-line comments (// ...) outside strings
-		config = JSON.parse(stripJsoncComments(raw))
+		config = Bun.JSONC.parse(raw) as WranglerConfig
 	}
 	return applyEnvOverrides(config, envName)
 }
@@ -120,46 +119,3 @@ function applyEnvOverrides(config: WranglerConfig, envName?: string): WranglerCo
 	}
 	return merged
 }
-
-// ─── JSONC Comment Stripping ───────────────────────────────────────────────
-
-function stripJsoncComments(input: string): string {
-	let result = ''
-	let i = 0
-	while (i < input.length) {
-		// String literal — copy as-is
-		if (input[i] === '"') {
-			result += '"'
-			i++
-			while (i < input.length && input[i] !== '"') {
-				if (input[i] === '\\') {
-					result += input[i]! + (input[i + 1] ?? '')
-					i += 2
-				} else {
-					result += input[i]!
-					i++
-				}
-			}
-			if (i < input.length) {
-				result += '"'
-				i++
-			}
-			continue
-		}
-		// Single-line comment
-		if (input[i] === '/' && input[i + 1] === '/') {
-			while (i < input.length && input[i] !== '\n') i++
-			continue
-		}
-		// Block comment
-		if (input[i] === '/' && input[i + 1] === '*') {
-			i += 2
-			while (i < input.length && !(input[i] === '*' && input[i + 1] === '/')) i++
-			i += 2
-			continue
-		}
-		result += input[i]!
-		i++
-	}
-	return result
-}

package/src/env.ts

@@ -355,9 +355,6 @@ export function buildEnv(
 		}
 	}
 
-	// Store reference for cloudflare:workers env export
-	setGlobalEnv(env)
-
 	return { env, registry }
 }
 

package/src/generation-manager.ts

@@ -146,10 +146,7 @@ export class GenerationManager {
 	}
 
 	private async _doReload(): Promise<Generation> {
-		// 1. Import fresh worker module using cache-busting query string
-		const workerModule = await import(`${this.workerPath}?v=${Date.now()}`)
-
-		// 1b. Configure executor factory with module/config paths (for isolated mode)
+		// 1. Configure executor factory with module/config paths (for isolated mode)
 		if (this.executorFactory && 'configure' in this.executorFactory) {
 			;(this.executorFactory as any).configure(this.workerPath, this._configPath)
 		}
@@ -157,14 +154,19 @@ export class GenerationManager {
 		// 2. Build new env with fresh binding instances (same underlying DB)
 		const { env, registry } = buildEnv(this.config, this.baseDir, this.executorFactory, this.browserConfig)
 
-		// 3. Wire DO and Workflow class references
-		wireClassRefs(registry, workerModule, env, this.workerRegistry)
-
-		// 4. Update globalEnv for cloudflare:workers env export (main worker only)
+		// 3. Update globalEnv BEFORE importing the worker module so that
+		//    top-level `import { env } from "cloudflare:workers"` sees bindings
+		//    during module evaluation (main worker only).
 		if (this.isMain) {
 			setGlobalEnv(env)
 		}
 
+		// 4. Import fresh worker module using cache-busting query string
+		const workerModule = await import(`${this.workerPath}?v=${Date.now()}`)
+
+		// 5. Wire DO and Workflow class references
+		wireClassRefs(registry, workerModule, env, this.workerRegistry)
+
 		// 5. Validate default export (or service worker fetch handler)
 		const defaultExport = workerModule.default
 		const classBasedExport = isEntrypointClass(defaultExport)

package/src/plugin.ts

@@ -15,7 +15,21 @@ import { globalEnv } from './env'
 import { getActiveExecutionContext } from './execution-context'
 import { getActiveContext } from './tracing/context'
 import { instrumentBinding } from './tracing/instrument'
-import { addSpanEvent, setSpanAttribute, startSpan } from './tracing/span'
+import { addSpanEvent, persistError, setSpanAttribute, startSpan } from './tracing/span' // ─── Userland tracing API ────────────────────────────────────────────
+ // Exposes a lightweight global that user code can call to create custom
+// spans visible in the Lopata dashboard.  In production (without Lopata)
+// the global is simply absent, so the user's thin wrapper becomes a no-op.
+;(globalThis as any).__lopata = {
+	trace<T>(name: string, attrsOrFn: Record<string, unknown> | (() => T | Promise<T>), maybeFn?: () => T | Promise<T>): Promise<T> {
+		const fn = typeof attrsOrFn === 'function' ? attrsOrFn : maybeFn!
+		const attributes = typeof attrsOrFn === 'function' ? undefined : attrsOrFn
+		return startSpan({ name, attributes }, fn)
+	},
+	setAttribute: setSpanAttribute,
+	addEvent(name: string, message?: string, attrs?: Record<string, unknown>): void {
+		addSpanEvent(name, 'info', message ?? '', attrs)
+	},
+}
 
 // Register global `caches` object (CacheStorage) with tracing
 const rawCacheStorage = new SqliteCacheStorage(getDatabase())
@@ -151,6 +165,10 @@ for (const method of consoleMethods) {
 		if (!ctx) return
 		const message = args.map(formatConsoleArg).join(' ')
 		addSpanEvent(`console.${method}`, method, message)
+		if (method === 'error') {
+			const errorArg = args.find((a) => a instanceof Error)
+			persistError(errorArg ?? new Error(message), 'console.error')
+		}
 	}
 }
 

package/src/tracing/global.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Lopata userland tracing API.
+ *
+ * Available on `globalThis.__lopata` when running under Lopata dev server.
+ * In production (Cloudflare Workers) the global is `undefined` — wrap calls
+ * in a thin helper that falls back to a no-op:
+ *
+ * ```ts
+ * // app/lib/trace.ts
+ * type TraceFn = <T>(name: string, fn: () => T | Promise<T>) => Promise<T>
+ *
+ * export const trace: TraceFn = (name, fn) =>
+ *   globalThis.__lopata?.trace(name, fn) ?? fn()
+ *
+ * export const setAttribute = (key: string, value: unknown) =>
+ *   globalThis.__lopata?.setAttribute(key, value)
+ *
+ * export const addEvent = (name: string, message?: string) =>
+ *   globalThis.__lopata?.addEvent(name, message)
+ * ```
+ *
+ * Add this file to your tsconfig types to get autocomplete:
+ * ```json
+ * { "compilerOptions": { "types": ["lopata/src/tracing/global"] } }
+ * ```
+ */
+
+interface LopataTracing {
+	/**
+	 * Create a traced span around `fn`. The span is visible in the Lopata
+	 * dashboard and becomes a child of the currently active span (if any).
+	 */
+	trace<T>(name: string, fn: () => T | Promise<T>): Promise<T>
+	/**
+	 * Create a traced span with custom attributes.
+	 */
+	trace<T>(name: string, attrs: Record<string, unknown>, fn: () => T | Promise<T>): Promise<T>
+
+	/**
+	 * Set an attribute on the currently active span.
+	 */
+	setAttribute(key: string, value: unknown): void
+
+	/**
+	 * Add an event (log entry) to the currently active span.
+	 */
+	addEvent(name: string, message?: string, attrs?: Record<string, unknown>): void
+}
+
+declare var __lopata: LopataTracing | undefined