wasm-idle 1.0.0 → 1.0.4

package/dist/playground/worker/python.js

@@ -11,6 +11,8 @@ self.document = {
     }
 };
 let stdinBufferPyodide, debugBufferPyodide, watchBufferPyodide, watchResultBufferPyodide, interruptBufferPyodide, pyodide, baseUrl = '', useAssetBridge = false;
+// Only the next matching run may reuse a successful package preparation.
+let preparedPackagesKey;
 const imageHook = `
 if not globals().get("__wasm_idle_img_inited__", False):
     globals()["__wasm_idle_img_inited__"] = True
@@ -172,8 +174,7 @@ const resolvePinnedPackageBaseUrl = (version) => {
 function postProgress(percent, stage) {
     self.postMessage({ progress: { percent, stage } });
 }
-async function importRuntimeAssetModule(asset) {
-    const loaded = await loadWorkerRuntimeAsset(asset);
+async function importRuntimeAssetModule(loaded) {
     const moduleUrl = URL.createObjectURL(new Blob([loaded.bytes.slice().buffer], {
         type: loaded.mimeType || 'text/javascript'
     }));
@@ -188,13 +189,21 @@ async function loadPyodide(path) {
     if (pyodide)
         return;
     const runtimeBaseUrl = path.endsWith('/') ? path : `${path}/`;
-    await importRuntimeAssetModule('pyodide.asm.js');
-    const runtimeModule = (await importRuntimeAssetModule('pyodide.mjs'));
+    // Download independent bootstrap files together, but preserve module evaluation order.
+    // The existing bounded loader (and host bridge, when configured) still owns every byte.
+    const [asmAsset, runtimeAsset, loadedLock] = await Promise.all([
+        loadWorkerRuntimeAsset('pyodide.asm.js'),
+        loadWorkerRuntimeAsset('pyodide.mjs'),
+        useAssetBridge ? undefined : loadWorkerRuntimeAsset('pyodide-lock.json')
+    ]);
+    await importRuntimeAssetModule(asmAsset);
+    const runtimeModule = (await importRuntimeAssetModule(runtimeAsset));
     let packageBaseUrl = runtimeBaseUrl;
     let lockFileContents;
     if (!useAssetBridge) {
         packageBaseUrl = resolvePinnedPackageBaseUrl(runtimeModule.version);
-        const loadedLock = await loadWorkerRuntimeAsset('pyodide-lock.json');
+        if (!loadedLock)
+            throw new Error('Python runtime lock file is unavailable');
         const parsedLock = parsePythonPackageLock(loadedLock.bytes);
         // The interceptor caps downloaded (including browser-decoded transport) archive bytes.
         // Pyodide owns package extraction after receiving that bounded archive.
@@ -217,6 +226,14 @@ async function loadPackages(code) {
         return;
     await pyodide.loadPackagesFromImports(code);
 }
+function packagePreparationKey(code, activePath, files = []) {
+    // Keep source boundaries and paths: joining contents alone can alias different workspaces.
+    return JSON.stringify([
+        code,
+        activePath ?? null,
+        files.map(({ path, content }) => [path, content])
+    ]);
+}
 function normalizeWorkspacePath(path) {
     return path
         .replaceAll('\\', '/')
@@ -241,6 +258,7 @@ self.onmessage = async (event) => {
         return;
     const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, assets, prepare, stdin, debug = false, breakpoints = [], pauseOnEntry = false, activePath, debugPath, workspaceFiles } = event.data;
     if (load) {
+        preparedPackagesKey = undefined;
         try {
             const runtimeAssets = assets;
             baseUrl = runtimeAssets?.baseUrl || baseUrl;
@@ -258,9 +276,11 @@ self.onmessage = async (event) => {
         }
     }
     else if (prepare) {
+        preparedPackagesKey = undefined;
         postMessage({ output: 'Loading packages...' });
         try {
             postProgress(5, 'Preparing Python workspace');
+            const preparationKey = packagePreparationKey(code, activePath, workspaceFiles);
             await loadPyodide(baseUrl);
             writeWorkspaceFiles(workspaceFiles);
             postProgress(15, 'Resolving Python imports');
@@ -268,22 +288,30 @@ self.onmessage = async (event) => {
                 code,
                 ...(workspaceFiles || []).map((file) => file.content)
             ].join('\n'));
+            preparedPackagesKey = preparationKey;
             postProgress(100, 'Python packages ready');
             postMessage({ output: ' Done.\n\r' });
             self.postMessage({ results: true });
         }
         catch (e) {
+            preparedPackagesKey = undefined;
             self.postMessage({ error: e.message || 'Unknown error' });
         }
     }
     else if (typeof code === 'string') {
+        const preparedKey = preparedPackagesKey;
+        // Consume before any await or user code, including executions that fail. Python can
+        // mutate imports and the filesystem, so this is not a cross-execution package cache.
+        preparedPackagesKey = undefined;
         try {
             await loadPyodide(baseUrl);
             writeWorkspaceFiles(workspaceFiles);
-            await loadPackages([
-                code,
-                ...(workspaceFiles || []).map((file) => file.content)
-            ].join('\n'));
+            if (preparedKey !== packagePreparationKey(code, activePath, workspaceFiles)) {
+                await loadPackages([
+                    code,
+                    ...(workspaceFiles || []).map((file) => file.content)
+                ].join('\n'));
+            }
         }
         catch (e) {
             self.postMessage({ error: e.message || 'Unknown error' });

package/dist/playground/worker/ruby.js

@@ -1,20 +1,32 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
 import { importRuntimeModule } from '../runtimeModule';
-import { RUBY_RUNTIME_VERIFIED_WASM_URL, rewriteVerifiedRubyRuntimeModule, verifyRubyRuntimePreflightPayload } from '@wasm-idle/core';
+import { RUBY_RUNTIME_VERIFIED_WASM_URL, normalizeWorkspacePath, RUBY_SPLIT_PROTOCOL, verifyRubySplitPayload, rewriteRubySplitRuntimeModule, parseRubyStdlibPack, createRubyStdlibPreopens, rewriteVerifiedRubyRuntimeModule, verifyRubyRuntimePreflightPayload } from '@wasm-idle/core';
 const encoder = new TextEncoder();
 let stdinBufferRuby = null;
 let runtimeState = 'uninitialized';
 let loadedRuntime = null;
-async function loadRubyModule(runtimePreflight, maxAssetBytes) {
+let preparedExecution = null;
+async function loadRubyModule(runtimePreflight, maxAssetBytes, context) {
     if (runtimeState !== 'uninitialized') {
         throw new Error('Ruby runtime is already loaded.');
     }
     runtimeState = 'loading';
     try {
-        const payload = await verifyRubyRuntimePreflightPayload(runtimePreflight, {
-            maxAssetBytes
-        });
-        const buffers = [payload.manifestBytes, payload.moduleJavaScriptBytes, payload.wasmBytes];
+        const split = !!runtimePreflight &&
+            typeof runtimePreflight === 'object' &&
+            Object.getOwnPropertyDescriptor(runtimePreflight, 'protocol')?.value ===
+                RUBY_SPLIT_PROTOCOL;
+        const payload = split
+            ? await verifyRubySplitPayload(runtimePreflight, { maxAssetBytes })
+            : await verifyRubyRuntimePreflightPayload(runtimePreflight, {
+                maxAssetBytes
+            });
+        const buffers = [
+            payload.manifestBytes,
+            payload.moduleJavaScriptBytes,
+            payload.wasmBytes,
+            ...('stdlibBytes' in payload ? [payload.stdlibBytes] : [])
+        ];
         if (buffers.some((bytes) => !ArrayBuffer.isView(bytes) ||
             Object.prototype.toString.call(bytes) !== '[object Uint8Array]' ||
             !(bytes.buffer instanceof ArrayBuffer) ||
@@ -24,7 +36,9 @@ async function loadRubyModule(runtimePreflight, maxAssetBytes) {
             throw new TypeError('Ruby execution worker requires unique owned runtime preflight bytes');
         }
         const wasmBytes = payload.wasmBytes;
-        const moduleSource = rewriteVerifiedRubyRuntimeModule(payload);
+        const moduleSource = 'stdlibBytes' in payload
+            ? rewriteRubySplitRuntimeModule(payload)
+            : rewriteVerifiedRubyRuntimeModule(payload);
         if (typeof Blob !== 'function' ||
             typeof URL.createObjectURL !== 'function' ||
             typeof URL.revokeObjectURL !== 'function') {
@@ -53,23 +67,44 @@ async function loadRubyModule(runtimePreflight, maxAssetBytes) {
             runtime.rubyStdlibWasmUrl !== RUBY_RUNTIME_VERIFIED_WASM_URL) {
             throw new Error('Ruby runtime module is missing required verified Ruby or WASI exports.');
         }
-        loadedRuntime = { module, runtime };
+        loadedRuntime = {
+            module,
+            runtime,
+            ...('stdlibBytes' in payload
+                ? { stdlib: parseRubyStdlibPack(payload.stdlibBytes) }
+                : {})
+        };
+        // Initialize only the interpreter; never evaluate user source during prewarm.
+        const candidate = await initializeRubyExecution(loadedRuntime, context, true);
+        preparedExecution = candidate.stdin.wasReadBeforeActivation ? null : candidate;
         runtimeState = 'ready';
         return loadedRuntime;
     }
     catch (error) {
         loadedRuntime = null;
+        preparedExecution = null;
         runtimeState = 'uninitialized';
         throw error;
     }
 }
-function createRubyStdin(runtime, initialStdin, requestInput) {
+function createRubyStdin(runtime, initialStdin, requestInput, deferred = false) {
     const { Fd, Inode, wasi } = runtime.wasiShim;
     return new (class extends Fd {
         ino = Inode.issue_ino();
         currentStdin = initialStdin;
         pendingBytes = null;
         fixedInitialStdin = initialStdin != null;
+        active = !deferred;
+        wasReadBeforeActivation = false;
+        activate(initial, provider) {
+            if (this.active)
+                throw new Error('Ruby stdin is already active.');
+            this.currentStdin = initial;
+            this.fixedInitialStdin = initial != null;
+            this.pendingBytes = null;
+            requestInput = provider;
+            this.active = true;
+        }
         fd_fdstat_get() {
             const fdstat = new wasi.Fdstat(wasi.FILETYPE_CHARACTER_DEVICE, 0);
             fdstat.fs_rights_base = BigInt(wasi.RIGHTS_FD_READ);
@@ -82,6 +117,12 @@ function createRubyStdin(runtime, initialStdin, requestInput) {
             };
         }
         fd_read(size) {
+            if (!this.active) {
+                // Do not request user input or block during speculative initialization.
+                // Such an initialization may have cached EOF in libc; never reuse it.
+                this.wasReadBeforeActivation = true;
+                return { ret: wasi.ERRNO_SUCCESS, data: new Uint8Array() };
+            }
             let bytes = this.pendingBytes;
             if (!bytes?.length) {
                 const chunk = this.readChunk();
@@ -142,13 +183,142 @@ function workspaceContents(runtime, workspaceFiles) {
     }
     return materializeWorkspaceTree(runtime, tree);
 }
+const defaultContext = () => ({
+    args: [],
+    workspaceFiles: [],
+    activePath: 'main.rb'
+});
+// This private bootstrap envelope contains data only, never source to evaluate or URLs.
+function decodeStartupContext(value) {
+    if (value === undefined)
+        return defaultContext();
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError('Invalid Ruby startup context.');
+    const input = value;
+    if (Object.keys(input).sort().join(',') !== 'activePath,args,workspaceFiles' ||
+        !Array.isArray(input.args) ||
+        input.args.some((arg) => typeof arg !== 'string') ||
+        !Array.isArray(input.workspaceFiles) ||
+        typeof input.activePath !== 'string') {
+        throw new TypeError('Invalid Ruby startup context.');
+    }
+    const workspaceFiles = input.workspaceFiles.map((file) => {
+        if (!file ||
+            typeof file !== 'object' ||
+            Object.keys(file).sort().join(',') !== 'content,path' ||
+            typeof file.path !== 'string' ||
+            typeof file.content !== 'string')
+            throw new TypeError('Invalid Ruby startup workspace.');
+        return { path: normalizeWorkspacePath(file.path), content: file.content };
+    });
+    return {
+        args: [...input.args],
+        workspaceFiles,
+        activePath: normalizeWorkspacePath(input.activePath)
+    };
+}
+const sameContext = (a, b) => a.activePath === b.activePath &&
+    a.args.length === b.args.length &&
+    a.args.every((value, index) => value === b.args[index]) &&
+    a.workspaceFiles.length === b.workspaceFiles.length &&
+    a.workspaceFiles.every((file, index) => file.path === b.workspaceFiles[index].path &&
+        file.content === b.workspaceFiles[index].content);
+async function initializeRubyExecution(loaded, context, deferred, initial = null, provider = () => null) {
+    const { runtime, module } = loaded;
+    // Snapshot the immutable startup context before awaiting VM initialization.
+    const snapshot = {
+        args: [...context.args],
+        activePath: context.activePath,
+        workspaceFiles: context.workspaceFiles.map((file) => ({
+            path: file.path,
+            content: file.content
+        }))
+    };
+    let active = !deferred;
+    let hasStdout = false, hasStderr = false;
+    let pendingBytes = 0;
+    const pending = [];
+    const emit = (output, error) => {
+        if (!output)
+            return;
+        if (error)
+            hasStderr = true;
+        else
+            hasStdout = true;
+        if (active)
+            postMessage({ output });
+        else {
+            pendingBytes += encoder.encode(output).byteLength;
+            if (pendingBytes > 64 * 1024)
+                throw new Error('Ruby initialization output exceeded 65536 bytes.');
+            pending.push(output);
+        }
+    };
+    const printer = runtime.consolePrinter({
+        stdout: (output) => emit(output, false),
+        stderr: (output) => emit(output, true)
+    });
+    const rubyStdin = createRubyStdin(runtime, initial, provider, deferred);
+    const { File, OpenFile, PreopenDirectory, WASI } = runtime.wasiShim;
+    const root = workspaceContents(runtime, snapshot.workspaceFiles);
+    // Preserve the complete split standard library and ancestor directories for realpath.
+    const preopens = loaded.stdlib
+        ? createRubyStdlibPreopens(loaded.stdlib, runtime.wasiShim, root)
+        : [new PreopenDirectory('/', root)];
+    // @ruby/wasm-wasi automatically requires /bundle/setup.rb while initializing.
+    // The split profile owns and verifies that mount. For the embedded profile, hide a
+    // same-named user directory until initialization completes so prewarm cannot run
+    // workspace source; the live root map is restored before the VM can be claimed.
+    const deferredUserBundle = loaded.stdlib ? undefined : root.get('bundle');
+    if (deferredUserBundle)
+        root.delete('bundle');
+    const wasiInstance = new WASI(['ruby.wasm', ...snapshot.args], ['USER=jungol'], [rubyStdin, new OpenFile(new File([])), new OpenFile(new File([])), ...preopens], { debug: false });
+    let vm;
+    try {
+        ({ vm } = await runtime.RubyVM.instantiateModule({
+            module,
+            wasip1: wasiInstance,
+            args: ['ruby.wasm', '-EUTF-8', '-e_=0', '--', ...snapshot.args],
+            addToImports(imports) {
+                printer.addToImports(imports);
+            },
+            setMemory(memory) {
+                printer.setMemory(memory);
+            }
+        }));
+    }
+    finally {
+        if (deferredUserBundle)
+            root.set('bundle', deferredUserBundle);
+    }
+    if (!vm || typeof vm.eval !== 'function')
+        throw new Error('Ruby VM initialization did not return an evaluator.');
+    return {
+        context: snapshot,
+        vm,
+        stdin: rubyStdin,
+        activate(initial, provider) {
+            if (active)
+                throw new Error('Ruby execution is already active.');
+            rubyStdin.activate(initial, provider);
+            active = true;
+            for (const output of pending.splice(0))
+                postMessage({ output });
+            pendingBytes = 0;
+        },
+        hasOutput: () => ({ stdout: hasStdout, stderr: hasStderr })
+    };
+}
 self.onmessage = async (event) => {
     const message = event.data;
     const { load, runtimePreflight, maxAssetBytes, buffer, code, prepare, args = [], stdin, activePath = 'main.rb', workspaceFiles = [], log } = message;
+    let ownsRuntimeState = false;
     try {
         if (Object.prototype.hasOwnProperty.call(message, 'load')) {
             const actualKeys = Object.keys(message).sort();
-            const expectedKeys = ['load', 'maxAssetBytes', 'runtimePreflight'];
+            const expectedKeys = Object.prototype.hasOwnProperty.call(message, 'startupContext')
+                ? ['load', 'maxAssetBytes', 'runtimePreflight', 'startupContext']
+                : ['load', 'maxAssetBytes', 'runtimePreflight'];
             if (load !== true ||
                 actualKeys.length !== expectedKeys.length ||
                 actualKeys.some((key, index) => key !== expectedKeys[index]) ||
@@ -156,8 +326,9 @@ self.onmessage = async (event) => {
                 maxAssetBytes <= 0) {
                 throw new Error('Ruby runtime load message has an invalid shape.');
             }
+            const context = decodeStartupContext(message.startupContext);
             postMessage({ progress: { percent: 5, stage: 'Loading Ruby runtime' } });
-            await loadRubyModule(runtimePreflight, maxAssetBytes);
+            await loadRubyModule(runtimePreflight, maxAssetBytes, context);
             postMessage({ progress: { percent: 100, stage: 'Ruby runtime ready' } });
             postMessage({ load: true });
             return;
@@ -167,57 +338,37 @@ self.onmessage = async (event) => {
             throw new Error('Ruby runtime is not ready.');
         }
         runtimeState = 'running';
-        const { module: rubyModule, runtime } = loadedRuntime;
+        ownsRuntimeState = true;
+        const context = { args, workspaceFiles, activePath };
+        if (preparedExecution && !sameContext(preparedExecution.context, context))
+            preparedExecution = null;
         if (prepare) {
+            if (!preparedExecution) {
+                const candidate = await initializeRubyExecution(loadedRuntime, context, true);
+                preparedExecution = candidate.stdin.wasReadBeforeActivation ? null : candidate;
+            }
             postMessage({ results: true });
-            runtimeState = 'ready';
             return;
         }
-        let stdout = '';
-        let stderr = '';
-        const printer = runtime.consolePrinter({
-            stdout(output) {
-                stdout += output;
-                if (output)
-                    postMessage({ output });
-            },
-            stderr(output) {
-                stderr += output;
-                if (output)
-                    postMessage({ output });
-            }
-        });
-        const hasInitialStdin = typeof stdin === 'string';
-        const rubyStdin = createRubyStdin(runtime, hasInitialStdin ? stdin : null, () => {
-            const chunk = waitForBufferedStdin(stdinBufferRuby, () => postMessage({ buffer: true }));
-            if (log) {
+        const initialStdin = typeof stdin === 'string' ? stdin : null;
+        // Capture this run's buffer; no retained VM may read a previous caller's input.
+        const inputBuffer = stdinBufferRuby;
+        const requestInput = () => {
+            const chunk = waitForBufferedStdin(inputBuffer, () => postMessage({ buffer: true }));
+            if (log)
                 console.log(chunk == null
                     ? '[wasm-idle:ruby-stdin] read(bytes=0, eof=true)'
                     : `[wasm-idle:ruby-stdin] read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
-            }
             return chunk;
-        });
-        const { File, OpenFile, PreopenDirectory, WASI } = runtime.wasiShim;
-        const fds = [
-            rubyStdin,
-            new OpenFile(new File([])),
-            new OpenFile(new File([])),
-            new PreopenDirectory('/', workspaceContents(runtime, workspaceFiles))
-        ];
-        const wasiInstance = new WASI(['ruby.wasm', ...args], ['USER=jungol'], fds, {
-            debug: false
-        });
-        const { vm } = await runtime.RubyVM.instantiateModule({
-            module: rubyModule,
-            wasip1: wasiInstance,
-            args: ['ruby.wasm', '-EUTF-8', '-e_=0', ...args],
-            addToImports(imports) {
-                printer.addToImports(imports);
-            },
-            setMemory(memory) {
-                printer.setMemory(memory);
-            }
-        });
+        };
+        // Claim before evaluation. A VM which has run user code is never cached.
+        let execution = preparedExecution;
+        preparedExecution = null;
+        if (execution)
+            execution.activate(initialStdin, requestInput);
+        else
+            execution = await initializeRubyExecution(loadedRuntime, context, false, initialStdin, requestInput);
+        const { vm } = execution;
         if (log) {
             console.log(`[wasm-idle:ruby-worker] eval start bytes=${code.length} activePath=${activePath}`);
         }
@@ -231,7 +382,7 @@ self.onmessage = async (event) => {
         });
         vm.eval(code);
         if (log) {
-            console.log(`[wasm-idle:ruby-worker] eval settled stdout=${String(Boolean(stdout))} stderr=${String(Boolean(stderr))}`);
+            console.log(`[wasm-idle:ruby-worker] eval settled stdout=${String(execution.hasOutput().stdout)} stderr=${String(execution.hasOutput().stderr)}`);
         }
         postMessage({ results: true });
     }
@@ -242,7 +393,7 @@ self.onmessage = async (event) => {
         postMessage({ error: error?.message || String(error) });
     }
     finally {
-        if (runtimeState === 'running')
+        if (ownsRuntimeState && runtimeState === 'running')
             runtimeState = 'ready';
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-idle",
-  "version": "1.0.0",
+  "version": "1.0.4",
   "description": "A simple web app to run code in the browser",
   "license": "MIT",
   "type": "module",
@@ -14,6 +14,7 @@
     "apps/*"
   ],
   "devDependencies": {
+    "acorn": "8.16.0",
     "@eslint/js": "^10.0.1",
     "@sveltejs/adapter-auto": "^7.0.1",
     "@sveltejs/adapter-static": "^3.0.10",
@@ -35,6 +36,7 @@
     "@typescript-eslint/parser": "^8.58.2",
     "@wasmer/sdk": "0.9.0",
     "assemblyscript": "0.28.17",
+    "esbuild": "0.28.0",
     "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-svelte": "^3.17.0",
@@ -59,15 +61,15 @@
     "vitest": "^4.1.4",
     "waforth": "0.20.1",
     "webr": "0.6.0",
-    "@wasm-idle/debug": "1.0.0",
-    "@wasm-idle/lsp": "1.0.0",
-    "@wasm-idle/terminal": "1.0.0"
+    "@wasm-idle/terminal": "1.0.4",
+    "@wasm-idle/debug": "1.0.4",
+    "@wasm-idle/lsp": "1.0.4"
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "^0.4.2",
     "fflate": "0.8.3",
-    "@wasm-idle/llvm-core": "1.0.0",
-    "@wasm-idle/core": "1.0.0"
+    "@wasm-idle/core": "1.0.4",
+    "@wasm-idle/llvm-core": "1.0.4"
   },
   "files": [
     "dist",
@@ -199,7 +201,7 @@
     "support:matrix": "node scripts/support-matrix.mjs write",
     "check:support-matrix": "node scripts/support-matrix.mjs check",
     "sync:page-runtimes": "pnpm run sync:pyodide && pnpm run sync:webr && pnpm run sync:wasm-of-js-of-ocaml && pnpm run sync:wasm-typescript && pnpm run sync:wasm-octave && pnpm run sync:wasm-prolog && pnpm run sync:wasm-gleam && pnpm run sync:wasm-perl && pnpm run sync:wasm-tcl && pnpm run sync:wasm-awk && pnpm run sync:wasm-pascal && pnpm run sync:wasm-forth && pnpm run sync:wasm-j && pnpm run sync:wasm-bqn && pnpm run sync:wasm-janet && pnpm run sync:wasm-julia && pnpm run sync:wasm-nim && pnpm run sync:wasm-ruby && pnpm run sync:wasm-bash && pnpm run sync:wasm-clojurescript",
-    "page:build": "pnpm run verify:page-c3 && pnpm run verify:page-lfortran && pnpm run build:page-runtimes && pnpm run sync:page-runtimes && pnpm run build:static-runtime-modules && pnpm run prepare:wasm-debug-release && pnpm run layer:static-runtimes && pnpm run compress:static-runtimes && pnpm run build && pnpm run compress:build-runtimes && pnpm run verify:page-c3 build && pnpm run verify:page-lfortran build",
+    "page:build": "pnpm run verify:page-c3 && pnpm run verify:page-lfortran && pnpm run prepare:test-assets -- clang && pnpm run build:page-runtimes && pnpm run sync:page-runtimes && pnpm run build:static-runtime-modules && pnpm run prepare:wasm-debug-release && pnpm run layer:static-runtimes && pnpm run compress:static-runtimes && pnpm run build && pnpm run compress:build-runtimes && pnpm run verify:page-c3 build && pnpm run verify:page-lfortran build",
     "package:root": "svelte-kit sync && node scripts/clean-package-output.mjs && svelte-package --tsconfig ./tsconfig.package.json && publint",
     "package": "pnpm run build:publish-deps && pnpm run package:root",
     "verify:package": "node scripts/verify-package.mjs",