lopata 0.19.2 → 0.20.1

package/src/bindings/flagship.ts

@@ -0,0 +1,117 @@
+import type { Database } from 'bun:sqlite'
+
+export type FlagType = 'boolean' | 'string' | 'number' | 'object'
+
+export interface FlagDetails<T> {
+	value: T
+	variant?: string
+	reason: 'STATIC' | 'DEFAULT' | 'ERROR' | 'TARGETING_MATCH'
+	errorCode?: string
+}
+
+type EvaluationContext = Record<string, unknown> | undefined
+
+interface FlagRow {
+	type: string
+	value: string
+	variant: string | null
+}
+
+/**
+ * Local implementation of the Cloudflare Flagship feature-flag binding.
+ * Flag values are stored in SQLite (`flagship_flags` table). When a flag is
+ * not found, the caller's `defaultValue` is returned with reason `DEFAULT`.
+ * Local dev does not implement targeting rules — the `context` argument is
+ * accepted for API compatibility but ignored during evaluation.
+ */
+export class FlagshipBinding {
+	private db: Database
+	private appId: string
+
+	constructor(db: Database, appId: string) {
+		this.db = db
+		this.appId = appId
+	}
+
+	async getBooleanValue(key: string, defaultValue: boolean, context?: EvaluationContext): Promise<boolean> {
+		return (await this.getBooleanValueDetails(key, defaultValue, context)).value
+	}
+
+	async getStringValue(key: string, defaultValue: string, context?: EvaluationContext): Promise<string> {
+		return (await this.getStringValueDetails(key, defaultValue, context)).value
+	}
+
+	async getNumberValue(key: string, defaultValue: number, context?: EvaluationContext): Promise<number> {
+		return (await this.getNumberValueDetails(key, defaultValue, context)).value
+	}
+
+	async getObjectValue<T>(key: string, defaultValue: T, context?: EvaluationContext): Promise<T> {
+		return (await this.getObjectValueDetails(key, defaultValue, context)).value
+	}
+
+	async getBooleanValueDetails(key: string, defaultValue: boolean, _context?: EvaluationContext): Promise<FlagDetails<boolean>> {
+		return this.evaluate('boolean', key, defaultValue, parseBoolean)
+	}
+
+	async getStringValueDetails(key: string, defaultValue: string, _context?: EvaluationContext): Promise<FlagDetails<string>> {
+		return this.evaluate('string', key, defaultValue, (v) => v)
+	}
+
+	async getNumberValueDetails(key: string, defaultValue: number, _context?: EvaluationContext): Promise<FlagDetails<number>> {
+		return this.evaluate('number', key, defaultValue, (v) => Number(v))
+	}
+
+	async getObjectValueDetails<T>(key: string, defaultValue: T, _context?: EvaluationContext): Promise<FlagDetails<T>> {
+		return this.evaluate('object', key, defaultValue, (v) => JSON.parse(v) as T)
+	}
+
+	private evaluate<T>(expectedType: FlagType, key: string, defaultValue: T, parse: (raw: string) => T): FlagDetails<T> {
+		const row = this.db
+			.query<FlagRow, [string, string]>('SELECT type, value, variant FROM flagship_flags WHERE app_id = ? AND flag_key = ?')
+			.get(this.appId, key)
+		if (!row) {
+			return { value: defaultValue, reason: 'DEFAULT' }
+		}
+		if (row.type !== expectedType) {
+			return { value: defaultValue, reason: 'ERROR', errorCode: 'TYPE_MISMATCH' }
+		}
+		try {
+			const parsed = parse(row.value)
+			return { value: parsed, variant: row.variant ?? undefined, reason: 'STATIC' }
+		} catch {
+			return { value: defaultValue, reason: 'ERROR', errorCode: 'PARSE_ERROR' }
+		}
+	}
+}
+
+function parseBoolean(raw: string): boolean {
+	const v = raw.toLowerCase()
+	if (v === 'true' || v === '1') return true
+	if (v === 'false' || v === '0') return false
+	throw new Error(`invalid boolean flag value: ${raw}`)
+}
+
+/**
+ * Programmatic helper to seed / override a flag value in the local store.
+ * Used by tests and (later) the dashboard.
+ */
+export function setFlagValue(
+	db: Database,
+	appId: string,
+	key: string,
+	type: FlagType,
+	value: unknown,
+	variant?: string,
+): void {
+	const raw = type === 'object' ? JSON.stringify(value) : String(value)
+	db.run(
+		`INSERT INTO flagship_flags (app_id, flag_key, type, value, variant, updated_at)
+		 VALUES (?, ?, ?, ?, ?, ?)
+		 ON CONFLICT(app_id, flag_key) DO UPDATE SET type = excluded.type, value = excluded.value, variant = excluded.variant, updated_at = excluded.updated_at`,
+		[appId, key, type, raw, variant ?? null, Date.now()],
+	)
+}
+
+export function deleteFlag(db: Database, appId: string, key: string): void {
+	db.run('DELETE FROM flagship_flags WHERE app_id = ? AND flag_key = ?', [appId, key])
+}

package/src/bindings/vpc-network.ts

@@ -0,0 +1,40 @@
+/**
+ * Local implementation of the Cloudflare VPC Networks binding (`vpc_networks`).
+ *
+ * On Cloudflare, this binding exposes a Fetcher-like `fetch()` method that
+ * routes the request through the bound tunnel or Cloudflare Mesh. The URL
+ * passed to `fetch()` determines the destination host/port.
+ *
+ * In local dev there is no tunnel overlay network, so we pass the request
+ * straight to the host system's stack — the caller is expected to arrange
+ * for the destination to be reachable locally (e.g. a dev service on a
+ * known port, or a VPN/WireGuard tunnel on the host).
+ */
+
+export interface VpcNetworkConfig {
+	networkId: string
+	bindingName: string
+}
+
+export class VpcNetworkBinding {
+	private config: VpcNetworkConfig
+
+	constructor(config: VpcNetworkConfig) {
+		this.config = config
+	}
+
+	get networkId(): string {
+		return this.config.networkId
+	}
+
+	async fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {
+		const request = input instanceof Request ? new Request(input, init) : new Request(input.toString(), init)
+		const url = new URL(request.url)
+		if (!url.host) {
+			throw new Error(
+				`VPC Network binding "${this.config.bindingName}" requires an absolute URL (with host), got: ${request.url}`,
+			)
+		}
+		return fetch(request)
+	}
+}

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

@@ -0,0 +1,143 @@
+/**
+ * Worker-thread entry for the `worker_loaders` binding.
+ *
+ * The main thread spawns this file as a Worker, sends an init message with
+ * the path to the dynamically-written main module + a serializable `env`
+ * object, then dispatches RPC commands. Each command invokes either the
+ * default export's `fetch()` (HTTP), `scheduled()` (cron), or a named method
+ * on a named entrypoint class.
+ *
+ * This is "fuzzy" isolation — the worker thread has its own heap and module
+ * graph but shares the same process, so `fetch()` / `connect()` / filesystem
+ * access behave identically to the parent.
+ */
+
+declare var self: Worker
+
+export interface LoaderInitMessage {
+	type: 'init'
+	mainModulePath: string
+	env: unknown
+	globalOutbound: 'allow' | 'block'
+}
+
+export type LoaderCommand =
+	| { type: 'fetch'; entrypoint?: string; url: string; method: string; headers: [string, string][]; body: ArrayBuffer | null }
+	| { type: 'scheduled'; entrypoint?: string; cron: string; scheduledTime: number }
+	| { type: 'rpc-call'; entrypoint?: string; method: string; args: unknown[] }
+
+export type LoaderResult =
+	| { type: 'fetch'; status: number; statusText: string; headers: [string, string][]; body: ArrayBuffer | null }
+	| { type: 'scheduled' }
+	| { type: 'rpc-call'; value: unknown }
+	| { type: 'error'; message: string; stack?: string; name?: string }
+
+export type MainToWorker = { type: 'init'; data: LoaderInitMessage } | { type: 'command'; id: number; command: LoaderCommand }
+export type WorkerToMain = { type: 'need-init' } | { type: 'ready' } | { type: 'result'; id: number; result: LoaderResult }
+
+let loadedModule: Record<string, unknown> | null = null
+let loaderEnv: unknown = {}
+let networkBlocked = false
+
+self.onmessage = async (event: MessageEvent<MainToWorker>) => {
+	const msg = event.data
+	if (msg.type === 'init') {
+		try {
+			await init(msg.data)
+			self.postMessage({ type: 'ready' } satisfies WorkerToMain)
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err))
+			self.postMessage(
+				{
+					type: 'result',
+					id: -1,
+					result: { type: 'error', message: `Worker init failed: ${error.message}`, stack: error.stack, name: error.name },
+				} satisfies WorkerToMain,
+			)
+		}
+		return
+	}
+	if (msg.type === 'command') {
+		const result = await handleCommand(msg.command)
+		self.postMessage({ type: 'result', id: msg.id, result } satisfies WorkerToMain)
+	}
+}
+
+self.postMessage({ type: 'need-init' } satisfies WorkerToMain)
+
+async function init(data: LoaderInitMessage): Promise<void> {
+	loaderEnv = data.env ?? {}
+	networkBlocked = data.globalOutbound === 'block'
+	if (networkBlocked) {
+		const originalFetch = globalThis.fetch
+		globalThis.fetch = ((() => {
+			throw new Error('Dynamic Worker has globalOutbound=null — fetch() is blocked')
+		}) as unknown) as typeof globalThis.fetch // Keep reference so any test that stubs fetch is still observable
+		;(globalThis as unknown as { __lopata_original_fetch?: typeof originalFetch }).__lopata_original_fetch = originalFetch
+	}
+	loadedModule = await import(data.mainModulePath) as Record<string, unknown>
+}
+
+function resolveEntrypoint(name?: string): Record<string, unknown> {
+	if (!loadedModule) throw new Error('Worker not initialized')
+	if (name) {
+		const exp = loadedModule[name]
+		if (!exp) throw new Error(`Entrypoint "${name}" not exported from main module`)
+		// If the export is a class, instantiate it (WorkerEntrypoint-style)
+		if (typeof exp === 'function') {
+			const ctx = { waitUntil() {}, passThroughOnException() {} }
+			try {
+				return new (exp as new(ctx: unknown, env: unknown) => Record<string, unknown>)(ctx, loaderEnv)
+			} catch {
+				return exp as unknown as Record<string, unknown>
+			}
+		}
+		return exp as Record<string, unknown>
+	}
+	const def = loadedModule.default
+	if (!def) throw new Error('Main module has no default export')
+	return def as Record<string, unknown>
+}
+
+async function handleCommand(cmd: LoaderCommand): Promise<LoaderResult> {
+	try {
+		const entrypoint = resolveEntrypoint(cmd.entrypoint)
+		if (cmd.type === 'fetch') {
+			const handler = entrypoint.fetch as ((req: Request, env: unknown, ctx: unknown) => Response | Promise<Response>) | undefined
+			if (typeof handler !== 'function') throw new Error('Entrypoint has no fetch() handler')
+			const request = new Request(cmd.url, {
+				method: cmd.method,
+				headers: cmd.headers,
+				body: cmd.body ? cmd.body : null,
+			})
+			const ctx = { waitUntil(_p: Promise<unknown>) {}, passThroughOnException() {} }
+			const response = await handler.call(entrypoint, request, loaderEnv, ctx)
+			const buf = await response.arrayBuffer()
+			return {
+				type: 'fetch',
+				status: response.status,
+				statusText: response.statusText,
+				headers: Array.from(response.headers.entries()),
+				body: buf.byteLength ? buf : null,
+			}
+		}
+		if (cmd.type === 'scheduled') {
+			const handler = entrypoint.scheduled as ((event: unknown, env: unknown, ctx: unknown) => unknown) | undefined
+			if (typeof handler !== 'function') throw new Error('Entrypoint has no scheduled() handler')
+			const event = { cron: cmd.cron, scheduledTime: cmd.scheduledTime, type: 'scheduled' }
+			const ctx = { waitUntil(_p: Promise<unknown>) {}, passThroughOnException() {} }
+			await handler.call(entrypoint, event, loaderEnv, ctx)
+			return { type: 'scheduled' }
+		}
+		if (cmd.type === 'rpc-call') {
+			const fn = entrypoint[cmd.method]
+			if (typeof fn !== 'function') throw new Error(`Method "${cmd.method}" is not a function on entrypoint`)
+			const value = await (fn as (...args: unknown[]) => unknown).apply(entrypoint, cmd.args)
+			return { type: 'rpc-call', value }
+		}
+		throw new Error(`Unknown command type: ${(cmd as { type: string }).type}`)
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err))
+		return { type: 'error', message: error.message, stack: error.stack, name: error.name }
+	}
+}

package/src/bindings/worker-loader.ts

@@ -0,0 +1,325 @@
+/**
+ * Local implementation of the Cloudflare `worker_loaders` binding.
+ *
+ * Exposes `env.LOADER.load(code)` / `env.LOADER.get(id, callback)`. Each load
+ * spawns a Bun Worker thread (see `worker-loader-entry.ts`) that runs the
+ * supplied code with its own module graph. Isolation is "fuzzy" — worker
+ * threads share the process with the parent but have separate heaps.
+ *
+ * Modules are written to `.lopata/worker-loader/<stub-id>/` before the Worker
+ * imports the entry point. This keeps the implementation simple at the cost
+ * of not supporting languages Bun can't execute directly (CF's `py`, Rust,
+ * etc. are rejected in v1).
+ */
+
+import { randomUUIDv7 } from 'bun'
+import { mkdirSync, rmSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import type { LoaderCommand, LoaderInitMessage, LoaderResult, MainToWorker, WorkerToMain } from './worker-loader-entry'
+
+export type WorkerCodeModule =
+	| string
+	| { js: string }
+	| { cjs: string }
+	| { text: string }
+	| { data: ArrayBuffer }
+	| { json: unknown }
+
+export interface WorkerCode {
+	compatibilityDate: string
+	compatibilityFlags?: string[]
+	mainModule: string
+	modules: Record<string, WorkerCodeModule>
+	env?: Record<string, unknown>
+	globalOutbound?: unknown | null
+	allowExperimental?: boolean
+	tails?: unknown[]
+	limits?: { cpuMs?: number; subRequests?: number }
+}
+
+const WORKER_ENTRY_PATH = resolve(dirname(new URL(import.meta.url).pathname), 'worker-loader-entry.ts')
+
+interface PendingCommand {
+	resolve: (result: LoaderResult) => void
+	reject: (err: Error) => void
+}
+
+type CodeSource = WorkerCode | (() => WorkerCode | Promise<WorkerCode>)
+
+export class WorkerStub {
+	private readonly id: string
+	private readonly codeSource: CodeSource
+	private _resolvedCode: WorkerCode | null = null
+	private readonly workDir: string
+	private _worker: Worker | null = null
+	private _ready: Promise<void> | null = null
+	private _pending = new Map<number, PendingCommand>()
+	private _nextCmdId = 1
+	private _disposed = false
+	private _disposeTimer: Timer | null = null
+
+	constructor(id: string, code: CodeSource, baseDir: string) {
+		this.id = id
+		this.codeSource = code
+		this.workDir = join(baseDir, id)
+		if (typeof code !== 'function') {
+			this._resolvedCode = code
+		}
+	}
+
+	private async _resolveCode(): Promise<WorkerCode> {
+		if (this._resolvedCode) return this._resolvedCode
+		const code = await (this.codeSource as () => WorkerCode | Promise<WorkerCode>)()
+		validateCode(code)
+		this._resolvedCode = code
+		return code
+	}
+
+	private async _ensureReady(): Promise<void> {
+		if (this._ready) return this._ready
+		this._ready = this._boot()
+		return this._ready
+	}
+
+	private async _boot(): Promise<void> {
+		const code = await this._resolveCode()
+		mkdirSync(this.workDir, { recursive: true })
+		const mainPath = await writeModules(this.workDir, code.modules, code.mainModule)
+
+		const worker = new Worker(WORKER_ENTRY_PATH)
+		this._worker = worker
+
+		let readyResolve: () => void
+		let readyReject: (err: Error) => void
+		const ready = new Promise<void>((res, rej) => {
+			readyResolve = res
+			readyReject = rej
+		})
+
+		worker.onmessage = (event: MessageEvent<WorkerToMain>) => {
+			const msg = event.data
+			if (msg.type === 'need-init') {
+				const init: LoaderInitMessage = {
+					type: 'init',
+					mainModulePath: mainPath,
+					env: sanitizeEnv(code.env),
+					globalOutbound: code.globalOutbound === null ? 'block' : 'allow',
+				}
+				worker.postMessage({ type: 'init', data: init } satisfies MainToWorker)
+				return
+			}
+			if (msg.type === 'ready') {
+				readyResolve()
+				return
+			}
+			if (msg.type === 'result') {
+				if (msg.id === -1 && msg.result.type === 'error') {
+					readyReject(new Error(msg.result.message))
+					return
+				}
+				const pending = this._pending.get(msg.id)
+				if (!pending) return
+				this._pending.delete(msg.id)
+				if (msg.result.type === 'error') {
+					const err = new Error(msg.result.message)
+					if (msg.result.stack) err.stack = msg.result.stack
+					if (msg.result.name) err.name = msg.result.name
+					pending.reject(err)
+				} else {
+					pending.resolve(msg.result)
+				}
+			}
+		}
+
+		worker.onerror = (err: ErrorEvent) => {
+			readyReject(new Error(err.message || 'Worker error'))
+			for (const pending of this._pending.values()) {
+				pending.reject(new Error(err.message || 'Worker error'))
+			}
+			this._pending.clear()
+		}
+
+		await ready
+	}
+
+	private _send(command: LoaderCommand): Promise<LoaderResult> {
+		if (this._disposed) throw new Error('WorkerStub has been disposed')
+		const id = this._nextCmdId++
+		return new Promise((resolve, reject) => {
+			this._pending.set(id, { resolve, reject })
+			this._ensureReady()
+				.then(() => {
+					this._worker!.postMessage({ type: 'command', id, command } satisfies MainToWorker)
+				})
+				.catch(err => {
+					this._pending.delete(id)
+					reject(err)
+				})
+		})
+	}
+
+	getEntrypoint(name?: string): EntrypointProxy {
+		return createEntrypointProxy(this, name)
+	}
+
+	/** @internal */
+	async _fetch(entrypoint: string | undefined, request: Request): Promise<Response> {
+		const body = request.body ? await request.arrayBuffer() : null
+		const result = await this._send({
+			type: 'fetch',
+			entrypoint,
+			url: request.url,
+			method: request.method,
+			headers: Array.from(request.headers.entries()),
+			body,
+		})
+		if (result.type !== 'fetch') throw new Error(`Unexpected result type: ${result.type}`)
+		return new Response(result.body, {
+			status: result.status,
+			statusText: result.statusText,
+			headers: result.headers,
+		})
+	}
+
+	/** @internal */
+	async _scheduled(entrypoint: string | undefined, cron: string, scheduledTime: number): Promise<void> {
+		const result = await this._send({ type: 'scheduled', entrypoint, cron, scheduledTime })
+		if (result.type !== 'scheduled') throw new Error(`Unexpected result type: ${result.type}`)
+	}
+
+	/** @internal */
+	async _rpcCall(entrypoint: string | undefined, method: string, args: unknown[]): Promise<unknown> {
+		const result = await this._send({ type: 'rpc-call', entrypoint, method, args })
+		if (result.type !== 'rpc-call') throw new Error(`Unexpected result type: ${result.type}`)
+		return result.value
+	}
+
+	dispose(): void {
+		if (this._disposed) return
+		this._disposed = true
+		if (this._disposeTimer) clearTimeout(this._disposeTimer)
+		if (this._worker) {
+			try {
+				this._worker.terminate()
+			} catch {}
+		}
+		try {
+			rmSync(this.workDir, { recursive: true, force: true })
+		} catch {}
+	}
+}
+
+export interface EntrypointProxy {
+	fetch(request: Request | string | URL, init?: RequestInit): Promise<Response>
+	scheduled(event: { cron: string; scheduledTime?: number }): Promise<void>
+	[method: string]: unknown
+}
+
+function createEntrypointProxy(stub: WorkerStub, entrypoint?: string): EntrypointProxy {
+	const target = Object.create(null) as EntrypointProxy
+	return new Proxy(target, {
+		get(_t, prop: string | symbol) {
+			if (typeof prop !== 'string') return undefined
+			if (prop === 'fetch') {
+				return async (input: Request | string | URL, init?: RequestInit) => {
+					const request = input instanceof Request ? new Request(input, init) : new Request(input.toString(), init)
+					return stub._fetch(entrypoint, request)
+				}
+			}
+			if (prop === 'scheduled') {
+				return async (event: { cron?: string; scheduledTime?: number }) => {
+					return stub._scheduled(entrypoint, event.cron ?? '* * * * *', event.scheduledTime ?? Date.now())
+				}
+			}
+			if (prop === 'then' || prop === 'catch' || prop === 'finally') return undefined
+			return (...args: unknown[]) => stub._rpcCall(entrypoint, prop, args)
+		},
+	}) as EntrypointProxy
+}
+
+export class WorkerLoaderBinding {
+	private readonly baseDir: string
+	private readonly cache = new Map<string, WorkerStub>()
+
+	constructor(baseDir: string) {
+		this.baseDir = baseDir
+		mkdirSync(this.baseDir, { recursive: true })
+	}
+
+	load(code: WorkerCode): WorkerStub {
+		validateCode(code)
+		const id = randomUUIDv7()
+		return new WorkerStub(id, code, this.baseDir)
+	}
+
+	get(id: string, getCodeCallback: () => Promise<WorkerCode> | WorkerCode): WorkerStub {
+		const existing = this.cache.get(id)
+		if (existing) return existing
+		// Defer invoking the callback until the stub is first used — matches
+		// Cloudflare's behavior (get() returns synchronously, code resolution
+		// happens lazily on first fetch/rpc call).
+		const stub = new WorkerStub(id, getCodeCallback, this.baseDir)
+		this.cache.set(id, stub)
+		return stub
+	}
+
+	disposeAll(): void {
+		for (const stub of this.cache.values()) stub.dispose()
+		this.cache.clear()
+	}
+}
+
+function validateCode(code: WorkerCode): void {
+	if (!code.compatibilityDate) throw new Error('WorkerCode.compatibilityDate is required')
+	if (!code.mainModule) throw new Error('WorkerCode.mainModule is required')
+	if (!code.modules || typeof code.modules !== 'object') throw new Error('WorkerCode.modules must be an object')
+	if (!(code.mainModule in code.modules)) throw new Error(`mainModule "${code.mainModule}" not present in modules map`)
+}
+
+function sanitizeEnv(env: unknown): unknown {
+	if (env == null) return {}
+	try {
+		// Drop values that can't be structured-cloned (functions, classes, etc.)
+		return JSON.parse(JSON.stringify(env))
+	} catch {
+		return {}
+	}
+}
+
+async function writeModules(
+	workDir: string,
+	modules: Record<string, WorkerCodeModule>,
+	mainModule: string,
+): Promise<string> {
+	let mainPath = ''
+	for (const [name, content] of Object.entries(modules)) {
+		const filePath = join(workDir, name)
+		mkdirSync(dirname(filePath), { recursive: true })
+		const resolved = resolveModuleContent(name, content)
+		if (resolved.kind === 'binary') {
+			await Bun.write(filePath, resolved.body)
+		} else {
+			await Bun.write(filePath, resolved.body)
+		}
+		if (name === mainModule) mainPath = filePath
+	}
+	if (!mainPath) throw new Error(`mainModule "${mainModule}" could not be written`)
+	return mainPath
+}
+
+type ResolvedModule = { kind: 'text'; body: string } | { kind: 'binary'; body: ArrayBuffer }
+
+function resolveModuleContent(name: string, mod: WorkerCodeModule): ResolvedModule {
+	if (typeof mod === 'string') return { kind: 'text', body: mod }
+	if ('js' in mod) return { kind: 'text', body: mod.js }
+	if ('cjs' in mod) return { kind: 'text', body: mod.cjs }
+	if ('text' in mod) return { kind: 'text', body: mod.text }
+	if ('json' in mod) {
+		// Write raw JSON so the `.json` suffix triggers Bun's built-in JSON import; for
+		// non-.json names, fall back to an ES module default export.
+		if (name.endsWith('.json')) return { kind: 'text', body: JSON.stringify(mod.json) }
+		return { kind: 'text', body: `export default ${JSON.stringify(mod.json)}` }
+	}
+	if ('data' in mod) return { kind: 'binary', body: mod.data }
+	throw new Error(`Unsupported module type for "${name}": ${JSON.stringify(Object.keys(mod))}`)
+}