wasm-idle 1.0.7 → 1.0.9

package/dist/playground/wasmFennelVersion.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pinned receipt for the official single-file Fennel compiler (`fennel.lua`).
+ *
+ * The asset is the unmodified upstream release from https://fennel-lang.org/downloads/
+ * (MIT), gzip-compressed with `gzip -9 -n`. Fennel runs on the bundled wasm-lua
+ * (wasmoon) Lua VM, so this receipt only covers the compiler source.
+ */
+export declare const WASM_FENNEL_COMPILER_RECEIPT: Readonly<{
+    fennelVersion: "1.6.1";
+    path: "wasm-fennel/fennel-1.6.1.lua.gz";
+    bytes: 62385;
+    sha256: "108b12fe2acb5c47c74c461d7ecbf5e00fb72102a9b927df985b9b4b858e49c0";
+    uncompressedBytes: 301522;
+    uncompressedSha256: "c3d45602041e7d8ef8a212563573df040c48a85c648a29fb4597ebed4bc38ec2";
+}>;
+export type WasmFennelCompilerReceipt = {
+    readonly fennelVersion: string;
+    readonly bytes: number;
+    readonly sha256: string;
+    readonly uncompressedBytes: number;
+    readonly uncompressedSha256: string;
+};
+export declare const WASM_FENNEL_ASSET_VERSION: string;

package/dist/playground/wasmFennelVersion.js

@@ -0,0 +1,16 @@
+/**
+ * Pinned receipt for the official single-file Fennel compiler (`fennel.lua`).
+ *
+ * The asset is the unmodified upstream release from https://fennel-lang.org/downloads/
+ * (MIT), gzip-compressed with `gzip -9 -n`. Fennel runs on the bundled wasm-lua
+ * (wasmoon) Lua VM, so this receipt only covers the compiler source.
+ */
+export const WASM_FENNEL_COMPILER_RECEIPT = Object.freeze({
+    fennelVersion: '1.6.1',
+    path: 'wasm-fennel/fennel-1.6.1.lua.gz',
+    bytes: 62385,
+    sha256: '108b12fe2acb5c47c74c461d7ecbf5e00fb72102a9b927df985b9b4b858e49c0',
+    uncompressedBytes: 301522,
+    uncompressedSha256: 'c3d45602041e7d8ef8a212563573df040c48a85c648a29fb4597ebed4bc38ec2'
+});
+export const WASM_FENNEL_ASSET_VERSION = WASM_FENNEL_COMPILER_RECEIPT.sha256.slice(0, 16);

package/dist/playground/wasmGrainVersion.d.ts

@@ -0,0 +1,24 @@
+export declare const bundledGrainProfile: {
+    readonly profileId: "grain-0.7.2-jsoo-wasi-v1";
+    readonly grainVersion: "0.7.2";
+    readonly compilerJavaScript: {
+        readonly bytes: 20872240;
+        readonly sha256: "0a85cf0120aafd873e41eb901a18090453010f8f819074b77c14e1c359cafd1e";
+    };
+    readonly compilerStorage: {
+        readonly bytes: 3417153;
+        readonly sha256: "38cf8c42ed83447287e0bc54c768661a110b7becf1b93bdfdd6da30537c4e289";
+    };
+    readonly stdlibPack: {
+        readonly bytes: 5066092;
+        readonly sha256: "c56e83cbea649be5dd94ce98ae648b8f98e40203761ef7b1ad0a799048ee08eb";
+    };
+    readonly stdlibStorage: {
+        readonly bytes: 1653344;
+        readonly sha256: "7180475667a3129821be12aa787f449e58de62b0bb5c0e5472077b73b9e5cafa";
+    };
+};
+export declare const bundledGrainWorkerReceipt: {
+    readonly bytes: 28127;
+    readonly sha256: "c36b478c25f000a9a9ecdb186490cf8fce07ece9b5ac271031aa2e97f75cabab";
+};

package/dist/playground/wasmGrainVersion.js

@@ -0,0 +1,25 @@
+// Generated by scripts/sync-wasm-grain.mjs from the pinned upstream Grain release.
+export const bundledGrainProfile = {
+    profileId: 'grain-0.7.2-jsoo-wasi-v1',
+    grainVersion: '0.7.2',
+    compilerJavaScript: {
+        bytes: 20872240,
+        sha256: '0a85cf0120aafd873e41eb901a18090453010f8f819074b77c14e1c359cafd1e'
+    },
+    compilerStorage: {
+        bytes: 3417153,
+        sha256: '38cf8c42ed83447287e0bc54c768661a110b7becf1b93bdfdd6da30537c4e289'
+    },
+    stdlibPack: {
+        bytes: 5066092,
+        sha256: 'c56e83cbea649be5dd94ce98ae648b8f98e40203761ef7b1ad0a799048ee08eb'
+    },
+    stdlibStorage: {
+        bytes: 1653344,
+        sha256: '7180475667a3129821be12aa787f449e58de62b0bb5c0e5472077b73b9e5cafa'
+    }
+};
+export const bundledGrainWorkerReceipt = {
+    bytes: 28127,
+    sha256: 'c36b478c25f000a9a9ecdb186490cf8fce07ece9b5ac271031aa2e97f75cabab'
+};

package/dist/playground/wasmHyVersion.d.ts

@@ -0,0 +1,7 @@
+export declare const WASM_HY_VERSION = "1.3.1";
+export interface HyWheelReceipt {
+    readonly fileName: string;
+    readonly bytes: number;
+    readonly sha256: string;
+}
+export declare const WASM_HY_WHEELS: readonly HyWheelReceipt[];

package/dist/playground/wasmHyVersion.js

@@ -0,0 +1,15 @@
+// Pinned by scripts/sync-wasm-hy.mjs. Both wheels are pure Python and install into the bundled
+// Pyodide runtime; they are served from static/wasm-hy/ and never fetched from PyPI at runtime.
+export const WASM_HY_VERSION = '1.3.1';
+export const WASM_HY_WHEELS = Object.freeze([
+    Object.freeze({
+        fileName: 'funcparserlib-1.0.1-py2.py3-none-any.whl',
+        bytes: 17842,
+        sha256: '95da15d3f0d00b9b6f4bf04005c708af3faa115f7b45692ace064ebe758c68e8'
+    }),
+    Object.freeze({
+        fileName: 'hy-1.3.1-py3-none-any.whl',
+        bytes: 122343,
+        sha256: 'fef54e98b2080cd3993d5ce5a4310ef2b0fc756c972203b86fedc0e0f2908f53'
+    })
+]);

package/dist/playground/wasmReScriptVersion.d.ts

@@ -0,0 +1,20 @@
+export declare const WASM_RESCRIPT_RUNTIME_PROFILE: {
+    readonly profileId: "rescript-12.3.1-playground-commonjs";
+    readonly sourceRevision: "v12.3.1";
+    readonly manifestFingerprint: "c5cfee09555006071de09a4793ff080f9c49ef901fdb66d76ca16470dab7efc5";
+    readonly manifestReceipt: {
+        readonly bytes: 1406;
+        readonly sha256: "dddbbbdf2da0c91280267004875023ff9949c8815c6edff7057444cfcff25e61";
+    };
+    readonly compilerReceipt: {
+        readonly bytes: 1245489;
+        readonly sha256: "9d6988eff528fb577c10aa76f720e59c8737dc91c5a4a2f17496930b848ff51d";
+        readonly uncompressedBytes: 6496768;
+        readonly uncompressedSha256: "17b16598b473bcd56367f29fb76d300ffe0073c814af68710d3b46964b200202";
+    };
+};
+export declare const WASM_RESCRIPT_ASSET_VERSION: "c5cfee09555006071de09a4793ff080f9c49ef901fdb66d76ca16470dab7efc5";
+export declare const WASM_RESCRIPT_RUNNER_RECEIPT: {
+    readonly bytes: 22497;
+    readonly sha256: "9ed95127f988333a79c7591771c40f2d0fde07e5cb79da2543082582ffdd276d";
+};

package/dist/playground/wasmReScriptVersion.js

@@ -0,0 +1,20 @@
+export const WASM_RESCRIPT_RUNTIME_PROFILE = {
+    profileId: 'rescript-12.3.1-playground-commonjs',
+    sourceRevision: 'v12.3.1',
+    manifestFingerprint: 'c5cfee09555006071de09a4793ff080f9c49ef901fdb66d76ca16470dab7efc5',
+    manifestReceipt: {
+        bytes: 1406,
+        sha256: 'dddbbbdf2da0c91280267004875023ff9949c8815c6edff7057444cfcff25e61'
+    },
+    compilerReceipt: {
+        bytes: 1245489,
+        sha256: '9d6988eff528fb577c10aa76f720e59c8737dc91c5a4a2f17496930b848ff51d',
+        uncompressedBytes: 6496768,
+        uncompressedSha256: '17b16598b473bcd56367f29fb76d300ffe0073c814af68710d3b46964b200202'
+    }
+};
+export const WASM_RESCRIPT_ASSET_VERSION = WASM_RESCRIPT_RUNTIME_PROFILE.manifestFingerprint;
+export const WASM_RESCRIPT_RUNNER_RECEIPT = {
+    bytes: 22497,
+    sha256: '9ed95127f988333a79c7591771c40f2d0fde07e5cb79da2543082582ffdd276d'
+};

package/dist/playground/worker/cachedClangCompile.js

@@ -11,6 +11,7 @@ worker.onmessage = async ({ data }) => {
         return;
     started = true;
     const output = [];
+    let runtime;
     try {
         if (data.request.debug || (data.request.debugMode && data.request.debugMode !== 'none')) {
             throw new Error('Cached C/C++ execution does not support debug artifacts.');
@@ -43,7 +44,7 @@ worker.onmessage = async ({ data }) => {
         }
         // Every source cache miss gets fresh compiler memory and files. The host
         // session keeps the immutable tool Modules and verified asset bytes alive.
-        const runtime = new CachedRuntime({
+        runtime = new CachedRuntime({
             runtimeBaseUrl: data.runtimeBaseUrl,
             maxAssetBytes: data.maxAssetBytes,
             manifest,
@@ -71,15 +72,47 @@ worker.onmessage = async ({ data }) => {
                 message: 'Compiling source'
             }
         });
-        const artifact = await runtime.compileArtifact(data.request.code, data.request);
-        worker.postMessage({ type: 'compiled', artifact, stdout: output.join(''), stderr: '' });
+        const artifact = await runtime.compileArtifact(data.request.code, {
+            ...data.request,
+            precompiledHeader: data.precompiledHeader
+        });
+        if (runtime.usedPrecompiledHeader)
+            worker.postMessage({
+                type: 'progress',
+                progress: {
+                    stage: 'compile',
+                    completed: 100,
+                    total: 100,
+                    percent: 100,
+                    message: 'Compiled with precompiled <bits/stdc++.h>'
+                }
+            });
+        worker.postMessage({
+            type: 'compiled',
+            artifact,
+            stdout: output.join(''),
+            stderr: '',
+            ...buildingPrecompiledHeader(runtime)
+        });
     }
     catch (error) {
         worker.postMessage({
             type: 'error',
             error: error instanceof Error ? error.message : String(error),
             stdout: output.join(''),
-            stderr: ''
+            stderr: '',
+            ...buildingPrecompiledHeader(runtime)
         });
     }
+    // The program runs in another worker while this one, already holding the compiler and
+    // headers, prepares <bits/stdc++.h> for the next compile.
+    if (runtime && buildingPrecompiledHeader(runtime).precompiledHeader) {
+        const header = await runtime.buildPrecompiledHeader().catch(() => undefined);
+        worker.postMessage({ type: 'precompiled-header', header }, header ? [header.bytes.buffer] : []);
+    }
 };
+function buildingPrecompiledHeader(runtime) {
+    return runtime?.precompiledHeaderPlan && !runtime.usedPrecompiledHeader
+        ? { precompiledHeader: 'building' }
+        : {};
+}

package/dist/playground/worker/clang.js

@@ -8,6 +8,14 @@ import { BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES } from '../clangAssetIntegrity'
 let stdinBufferClang, debugBufferClang, watchBufferClang, watchResultBufferClang, interruptBufferClang, clang;
 let hasInitialStdinClang = false;
 let initialStdinClang = null;
+// Sent once per worker by the host; the runtime mounts it only for matching compiles.
+let precompiledHeaderClang;
+/** Ask the host to build the header in a helper worker when this compile could have used one. */
+function missingPrecompiledHeader() {
+    return clang?.precompiledHeaderPlan && !clang.usedPrecompiledHeader
+        ? { precompiledHeaderKey: clang.precompiledHeaderPlan.key }
+        : {};
+}
 function postProgress(percent, stage) {
     postMessage({ progress: { percent, stage } });
 }
@@ -51,6 +59,8 @@ self.onmessage = async (event) => {
         return;
     const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, assets, prepare, language, compileArgs, programArgs, activePath, workspaceFiles, cppVersion, cVersion, debugMode, debug, breakpoints, pauseOnEntry, stdin, maxAssetBytes } = event.data;
     const resolvedDebugMode = debugMode || (debug ? 'trace' : 'none');
+    if (event.data.precompiledHeader)
+        precompiledHeaderClang = event.data.precompiledHeader;
     if (load) {
         try {
             const runtimeAssets = assets;
@@ -62,6 +72,19 @@ self.onmessage = async (event) => {
             self.postMessage({ error: error.message || 'Unable to load the C/C++ runtime.' });
         }
     }
+    else if (event.data.precompileHeader) {
+        const header = await clang
+            .buildPrecompiledHeaderFor(code, {
+            language,
+            compileArgs,
+            activePath,
+            cppVersion,
+            cVersion,
+            debugMode: resolvedDebugMode
+        })
+            .catch(() => undefined);
+        self.postMessage({ precompiledHeader: header ?? null }, header ? [header.bytes.buffer] : []);
+    }
     else if (prepare) {
         stdinBufferClang = new Int32Array(buffer);
         debugBufferClang = new Int32Array(debugBuffer);
@@ -90,13 +113,16 @@ self.onmessage = async (event) => {
                 debugBuffer: debugBufferClang,
                 interruptBuffer: interruptBufferClang,
                 watchBuffer: watchBufferClang,
-                watchResultBuffer: watchResultBufferClang
+                watchResultBuffer: watchResultBufferClang,
+                precompiledHeader: precompiledHeaderClang
             });
+            if (clang.usedPrecompiledHeader)
+                postProgress(95, 'Compiled with precompiled <bits/stdc++.h>');
             postProgress(100, `${language === 'C' ? 'C' : 'C++'} program ready`);
-            self.postMessage({ results: true });
+            self.postMessage({ results: true, ...missingPrecompiledHeader() });
         }
         catch (error) {
-            self.postMessage({ error: error.message });
+            self.postMessage({ error: error.message, ...missingPrecompiledHeader() });
         }
     }
     else if (code) {
@@ -122,7 +148,8 @@ self.onmessage = async (event) => {
                     workspaceFiles,
                     cppVersion,
                     cVersion,
-                    debugMode: 'lldb'
+                    debugMode: 'lldb',
+                    precompiledHeader: precompiledHeaderClang
                 });
                 if (!artifact.debug) {
                     throw new Error('wasm-clang did not return an LLDB DWARF descriptor');
@@ -164,12 +191,13 @@ self.onmessage = async (event) => {
                 debugBuffer: debugBufferClang,
                 interruptBuffer: interruptBufferClang,
                 watchBuffer: watchBufferClang,
-                watchResultBuffer: watchResultBufferClang
+                watchResultBuffer: watchResultBufferClang,
+                precompiledHeader: precompiledHeaderClang
             });
-            self.postMessage({ results: true });
+            self.postMessage({ results: true, ...missingPrecompiledHeader() });
         }
         catch (error) {
-            self.postMessage({ error: error.message });
+            self.postMessage({ error: error.message, ...missingPrecompiledHeader() });
         }
     }
 };

package/dist/playground/worker/lua.js

@@ -1,10 +1,14 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { buildFennelCompileChunk, buildFennelRunChunk, loadFennelCompilerSource, parseFennelDiagnostic, stripHostLuaTraceback } from '../fennelBootstrap';
 let stdinBufferLua = null;
 let moduleUrl = '';
 let loadedModuleUrl = '';
 let runtimePromise = null;
 let compiledArtifact = null;
 let compiledCacheKey = '';
+// Set when this worker hosts Fennel: the verified official fennel.lua compiler source.
+let fennelSource = null;
+let runtimeLabel = 'Lua';
 async function loadRuntime(url) {
     if (!url) {
         throw new Error('Lua runtime is not configured. Set PUBLIC_WASM_LUA_MODULE_URL or runtimeAssets.lua.moduleUrl.');
@@ -51,8 +55,29 @@ function normalizeDiagnostic(diagnostic) {
         message: String(diagnostic?.message || '')
     };
 }
+async function compileFennel(runtime, fennel, code, fileName) {
+    // Run the official Fennel compiler once without stdin so syntax and compile errors are
+    // reported before execution starts.
+    const check = await runtime.executeBrowserLuaArtifact({ source: buildFennelCompileChunk(fennel, code, fileName), fileName }, { stdin: () => null });
+    if (check.exitCode !== 0) {
+        const message = stripHostLuaTraceback(check.stderr);
+        return {
+            success: false,
+            diagnostics: [parseFennelDiagnostic(message, fileName)],
+            stdout: '',
+            stderr: message
+        };
+    }
+    return {
+        success: true,
+        artifact: { source: buildFennelRunChunk(fennel, code, fileName), fileName },
+        diagnostics: [],
+        stdout: '',
+        stderr: ''
+    };
+}
 self.onmessage = async (event) => {
-    const { load, moduleUrl: nextModuleUrl, buffer, code, prepare, args = [], stdin, activePath = 'main.lua', workspaceFiles = [], log } = event.data;
+    const { load, moduleUrl: nextModuleUrl, fennelCompiler, buffer, code, prepare, args = [], stdin, activePath = 'main.lua', workspaceFiles = [], log } = event.data;
     try {
         if (load) {
             moduleUrl = nextModuleUrl;
@@ -60,6 +85,12 @@ self.onmessage = async (event) => {
                 console.log(`[wasm-idle:lua-worker] load moduleUrl=${moduleUrl}`);
             }
             await loadRuntime(moduleUrl);
+            if (fennelCompiler) {
+                fennelSource = await loadFennelCompilerSource(fennelCompiler);
+                runtimeLabel = 'Fennel';
+                compiledArtifact = null;
+                compiledCacheKey = '';
+            }
             postMessage({ load: true });
             return;
         }
@@ -74,11 +105,13 @@ self.onmessage = async (event) => {
             if (log) {
                 console.log(`[wasm-idle:lua-worker] compile start prepare=${String(prepare)} bytes=${code.length}`);
             }
-            const result = await runtime.compiler.compile({
-                code,
-                fileName: activePath,
-                log
-            });
+            const result = fennelSource
+                ? await compileFennel(runtime, fennelSource, code, activePath)
+                : await runtime.compiler.compile({
+                    code,
+                    fileName: activePath,
+                    log
+                });
             if (log) {
                 console.log(`[wasm-idle:lua-worker] compile settled success=${String(result.success)} stdout=${String(Boolean(result.stdout))} stderr=${String(Boolean(result.stderr))}`);
             }
@@ -92,7 +125,7 @@ self.onmessage = async (event) => {
                     result.diagnostics
                         ?.map((diagnostic) => diagnostic.message)
                         .join('\n') ||
-                    'Lua compilation failed');
+                    `${runtimeLabel} compilation failed`);
             }
             if (result.stderr)
                 postMessage({ output: result.stderr });
@@ -143,14 +176,18 @@ self.onmessage = async (event) => {
                     postMessage({ output });
             },
             stderr: (output) => {
-                if (output)
+                // Fennel errors are reported once, without the host Lua traceback, below.
+                if (output && !fennelSource)
                     postMessage({ output });
             }
         });
         if (execution.exitCode !== 0) {
-            throw new Error(execution.stderr
-                ? `Lua program exited with code ${execution.exitCode}\n${execution.stderr}`
-                : `Lua program exited with code ${execution.exitCode}`);
+            const stderr = fennelSource
+                ? stripHostLuaTraceback(execution.stderr)
+                : execution.stderr;
+            throw new Error(stderr
+                ? `${runtimeLabel} program exited with code ${execution.exitCode}\n${stderr}`
+                : `${runtimeLabel} program exited with code ${execution.exitCode}`);
         }
         postMessage({ results: true });
     }

package/dist/playground/worker/postgresql.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/playground/worker/postgresql.js

@@ -0,0 +1,205 @@
+import { importRuntimeModule } from '../runtimeModule';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let runtimeModuleUrl = '';
+let runtimePromise = null;
+async function fetchBytes(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`PostgreSQL runtime asset request failed (${response.status}): ${url}`);
+    }
+    return await response.arrayBuffer();
+}
+async function loadPostgresql(moduleUrl) {
+    if (!moduleUrl)
+        throw new Error('PostgreSQL runtime module URL is not configured.');
+    if (runtimeModuleUrl !== moduleUrl) {
+        runtimeModuleUrl = moduleUrl;
+        runtimePromise = null;
+    }
+    if (runtimePromise)
+        return await runtimePromise;
+    const pending = (async () => {
+        const runtime = await importRuntimeModule(moduleUrl);
+        const [PGlite, pgliteWasmModule, initdbWasmModule, fsBundle] = await Promise.all([
+            runtime.loadPGlite(),
+            fetchBytes(runtime.pgliteWasmUrl).then((bytes) => WebAssembly.compile(bytes)),
+            fetchBytes(runtime.pgliteInitdbWasmUrl).then((bytes) => WebAssembly.compile(bytes)),
+            fetchBytes(runtime.pgliteDataUrl).then((bytes) => new Blob([bytes]))
+        ]);
+        const options = { pgliteWasmModule, initdbWasmModule, fsBundle };
+        const template = await PGlite.create(options);
+        try {
+            const snapshot = await template.dumpDataDir('none');
+            return { PGlite, options, snapshot };
+        }
+        finally {
+            await template.close().catch(() => { });
+        }
+    })();
+    runtimePromise = pending;
+    pending.catch(() => {
+        if (runtimePromise === pending)
+            runtimePromise = null;
+    });
+    return await pending;
+}
+function normalizeWorkspacePath(path) {
+    return path
+        .replace(/^\/+/, '')
+        .split('/')
+        .filter((part) => part && part !== '.' && part !== '..' && !part.includes('\0'))
+        .join('/');
+}
+function collectSetupSql(activePath, workspaceFiles) {
+    const setupSql = [];
+    for (const file of workspaceFiles) {
+        if (!file || typeof file.path !== 'string' || typeof file.content !== 'string')
+            continue;
+        const normalizedPath = normalizeWorkspacePath(file.path);
+        if (!normalizedPath || normalizedPath === activePath)
+            continue;
+        if (!normalizedPath.toLowerCase().endsWith('.sql'))
+            continue;
+        setupSql.push({ path: normalizedPath, content: file.content });
+    }
+    return setupSql.sort((left, right) => left.path.localeCompare(right.path));
+}
+/** Frame one simple-query protocol message; the server runs the script exactly as written. */
+function simpleQueryMessage(sql) {
+    const text = encoder.encode(sql);
+    const message = new Uint8Array(text.byteLength + 6);
+    message[0] = 0x51; // 'Q'
+    new DataView(message.buffer).setInt32(1, text.byteLength + 5);
+    message.set(text, 5);
+    return message;
+}
+function stringifyCell(value) {
+    if (value == null)
+        return 'NULL';
+    return String(value);
+}
+function lineAndColumn(source, position) {
+    // The server reports a 1-based character (code point) offset into the query text.
+    const before = Array.from(source)
+        .slice(0, position - 1)
+        .join('');
+    const lines = before.split('\n');
+    return { lineNumber: lines.length, columnNumber: lines[lines.length - 1].length + 1 };
+}
+function formatServerMessage(message) {
+    const lines = [`${message.severity || 'ERROR'}:  ${message.message || ''}`];
+    if (message.detail)
+        lines.push(`DETAIL:  ${message.detail}`);
+    if (message.hint)
+        lines.push(`HINT:  ${message.hint}`);
+    return lines.join('\n');
+}
+/**
+ * Converts the backend's protocol replies into terminal text in server order. Rows use the
+ * server's own text representation, matching the tab-separated SQLite/DuckDB output.
+ */
+function renderMessages(messages) {
+    const chunks = [];
+    let error = null;
+    for (const message of messages) {
+        switch (message.name) {
+            case 'rowDescription':
+                chunks.push(`${(message.fields || []).map((field) => field.name).join('\t')}\n`);
+                break;
+            case 'dataRow':
+                chunks.push(`${(message.fields || []).map(stringifyCell).join('\t')}\n`);
+                break;
+            case 'copyData':
+                if (message.chunk)
+                    chunks.push(decoder.decode(message.chunk));
+                break;
+            case 'notice':
+                chunks.push(`${formatServerMessage(message)}\n`);
+                break;
+            case 'error':
+                error = message;
+                break;
+        }
+    }
+    return { output: chunks.join(''), error };
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, code, prepare, activePath = 'main.sql', workspaceFiles = [], stdin, log } = event.data;
+    try {
+        if (load) {
+            if (log)
+                console.log('[wasm-idle:postgresql-worker] load');
+            await loadPostgresql(nextModuleUrl || runtimeModuleUrl);
+            postMessage({ load: true });
+            return;
+        }
+        const runtime = await loadPostgresql(runtimeModuleUrl);
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const db = await runtime.PGlite.create({
+            ...runtime.options,
+            loadDataDir: runtime.snapshot
+        });
+        try {
+            const normalizedActivePath = normalizeWorkspacePath(activePath || 'main.sql');
+            for (const setup of collectSetupSql(normalizedActivePath, workspaceFiles)) {
+                await db.exec(setup.content);
+            }
+            // PGlite exposes caller-provided bytes as the server-side file /dev/blob, so
+            // `COPY ... FROM '/dev/blob'` and `pg_read_file('/dev/blob')` read program stdin.
+            await db._handleBlob(new Blob([typeof stdin === 'string' ? stdin : '']));
+            postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'PostgreSQL query started'
+                }
+            });
+            if (log) {
+                console.log(`[wasm-idle:postgresql-worker] exec start bytes=${code.length} activePath=${normalizedActivePath}`);
+            }
+            let rendered;
+            try {
+                const result = await db.execProtocol(simpleQueryMessage(code), {
+                    throwOnError: false
+                });
+                rendered = renderMessages(result.messages);
+            }
+            finally {
+                await db._cleanupBlob().catch(() => { });
+            }
+            if (rendered.output)
+                postMessage({ output: rendered.output });
+            if (rendered.error) {
+                const position = Number(rendered.error.position);
+                if (Number.isSafeInteger(position) && position > 0) {
+                    postMessage({
+                        diagnostic: {
+                            fileName: normalizedActivePath,
+                            ...lineAndColumn(code, position),
+                            severity: 'error',
+                            message: rendered.error.message || 'PostgreSQL error'
+                        }
+                    });
+                }
+                postMessage({ error: formatServerMessage(rendered.error) });
+                return;
+            }
+            if (log)
+                console.log('[wasm-idle:postgresql-worker] exec settled');
+        }
+        finally {
+            await db.close().catch(() => { });
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log)
+            console.error('[wasm-idle:postgresql-worker] failed', error);
+        postMessage({ error: error?.message || String(error) });
+    }
+};