wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/ocaml.js

@@ -1,13 +1,34 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { fetchRuntimeAssetBytes } from './runtimeAssetFetch';
+const MAX_OCAML_MANIFEST_BYTES = 4 * 1024 * 1024;
+const MAX_OCAML_RUNTIME_ENTRY_BYTES = 32 * 1024 * 1024;
+const DEFAULT_MAX_OCAML_ASSET_BYTES = 128 * 1024 * 1024;
+const textDecoder = new TextDecoder();
 let moduleUrl = '';
 let manifestUrl = '';
-let loadedModuleUrl = '';
-let loadedManifestUrl = '';
+let moduleReceipt = null;
+let manifestReceipt = null;
+let maxAssetBytes = DEFAULT_MAX_OCAML_ASSET_BYTES;
+let loadedModuleIdentity = '';
+let loadedManifestIdentity = '';
+let loadedManifestMaxAssetBytes = 0;
 let compilerPromise = null;
 let manifestPromise = null;
 let compiledResult = null;
 let compiledCacheKey = '';
 let stdinBufferOcaml = null;
+function requireOuterAssetReceipt(value, label) {
+    if (!value ||
+        !Number.isSafeInteger(value.bytes) ||
+        value.bytes <= 0 ||
+        typeof value.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(value.sha256)) {
+        throw new TypeError(`OCaml ${label} receipt is invalid`);
+    }
+    return Object.freeze({ bytes: value.bytes, sha256: value.sha256 });
+}
+const outerAssetIdentity = (url, receipt) => JSON.stringify([url, receipt.bytes, receipt.sha256]);
 function appendTrailingNewline(text) {
     return text.endsWith('\n') ? text : `${text}\n`;
 }
@@ -34,21 +55,27 @@ function rewriteAbsoluteBundleUrl(url, currentManifestUrl) {
     const basePath = manifestLocation.pathname.replace(/\/wasm-of-js-of-ocaml\/browser-native-bundle\/browser-native-manifest\.v1\.json$/, '');
     return new URL(`${basePath}${url}`, manifestLocation.origin).toString();
 }
+function rewriteManifestAsset(asset, currentManifestUrl) {
+    return {
+        ...asset,
+        url: rewriteAbsoluteBundleUrl(asset.url, currentManifestUrl)
+    };
+}
 function rewriteManifest(manifest, currentManifestUrl) {
     return {
         ...manifest,
-        findlibConf: rewriteAbsoluteBundleUrl(manifest.findlibConf, currentManifestUrl),
+        findlibConf: rewriteManifestAsset(manifest.findlibConf, currentManifestUrl),
         tools: {
-            ocamlc: rewriteAbsoluteBundleUrl(manifest.tools.ocamlc, currentManifestUrl),
-            js_of_ocaml: rewriteAbsoluteBundleUrl(manifest.tools.js_of_ocaml, currentManifestUrl),
-            wasm_of_ocaml: rewriteAbsoluteBundleUrl(manifest.tools.wasm_of_ocaml, currentManifestUrl)
+            ocamlc: rewriteManifestAsset(manifest.tools.ocamlc, currentManifestUrl),
+            js_of_ocaml: rewriteManifestAsset(manifest.tools.js_of_ocaml, currentManifestUrl),
+            wasm_of_ocaml: rewriteManifestAsset(manifest.tools.wasm_of_ocaml, currentManifestUrl)
         },
         ...(manifest.binaryenTools
             ? {
                 binaryenTools: {
-                    wasm_opt: rewriteAbsoluteBundleUrl(manifest.binaryenTools.wasm_opt, currentManifestUrl),
-                    wasm_merge: rewriteAbsoluteBundleUrl(manifest.binaryenTools.wasm_merge, currentManifestUrl),
-                    wasm_metadce: rewriteAbsoluteBundleUrl(manifest.binaryenTools.wasm_metadce, currentManifestUrl)
+                    wasm_opt: rewriteManifestAsset(manifest.binaryenTools.wasm_opt, currentManifestUrl),
+                    wasm_merge: rewriteManifestAsset(manifest.binaryenTools.wasm_merge, currentManifestUrl),
+                    wasm_metadce: rewriteManifestAsset(manifest.binaryenTools.wasm_metadce, currentManifestUrl)
                 }
             }
             : {}),
@@ -74,18 +101,58 @@ function rewriteManifest(manifest, currentManifestUrl) {
         }))
     };
 }
-async function loadCompiler(nextModuleUrl) {
+function prepareVerifiedModuleSource(bytes, nextModuleUrl) {
+    const source = textDecoder.decode(bytes);
+    const withAbsoluteImports = source.replace(/(\bfrom\s+|\bimport\s*(?:\(\s*)?)(['"])(\.{1,2}\/[^'"]+)\2/gu, (_match, prefix, quote, specifier) => `${prefix}${quote}${new URL(specifier, nextModuleUrl).href}${quote}`);
+    return withAbsoluteImports.replace(/\bimport\.meta\.url\b/gu, JSON.stringify(nextModuleUrl));
+}
+async function loadCompiler(nextModuleUrl, nextReceipt, nextMaxAssetBytes) {
     if (!nextModuleUrl) {
         throw new Error('OCaml runtime is not configured. Set runtimeAssets.ocaml.moduleUrl and runtimeAssets.ocaml.manifestUrl or sync the bundled wasm-of-js-of-ocaml assets.');
     }
-    if (loadedModuleUrl === nextModuleUrl && compilerPromise) {
+    if (nextReceipt.bytes > nextMaxAssetBytes) {
+        throw new Error(`OCaml module exceeds the ${nextMaxAssetBytes} byte limit`);
+    }
+    const identity = outerAssetIdentity(nextModuleUrl, nextReceipt);
+    if (loadedModuleIdentity === identity && compilerPromise) {
         return await compilerPromise;
     }
-    loadedModuleUrl = nextModuleUrl;
+    loadedModuleIdentity = identity;
     compiledResult = null;
     compiledCacheKey = '';
     compilerPromise = (async () => {
-        const module = (await import(/* @vite-ignore */ nextModuleUrl));
+        const bytes = await fetchRuntimeAssetBytes({
+            url: nextModuleUrl,
+            label: 'OCaml runtime module',
+            cache: 'no-store',
+            maxAssetBytes: nextReceipt.bytes
+        });
+        await verifyRuntimeAssetIntegrity({
+            asset: nextModuleUrl,
+            bytes,
+            expected: nextReceipt,
+            runtimeId: 'OCAML'
+        });
+        if (typeof URL.createObjectURL !== 'function' ||
+            typeof URL.revokeObjectURL !== 'function') {
+            throw new Error('OCaml runtime requires Blob URL support');
+        }
+        const verifiedModuleUrl = URL.createObjectURL(new Blob([prepareVerifiedModuleSource(bytes, nextModuleUrl)], {
+            type: 'text/javascript'
+        }));
+        let module;
+        try {
+            module = (await import(
+            /* @vite-ignore */ verifiedModuleUrl));
+        }
+        finally {
+            try {
+                URL.revokeObjectURL(verifiedModuleUrl);
+            }
+            catch {
+                // Blob URL cleanup must not replace the verified module import outcome.
+            }
+        }
         if (typeof module.compile !== 'function') {
             throw new Error('wasm-of-js-of-ocaml bundle must export compile');
         }
@@ -96,22 +163,79 @@ async function loadCompiler(nextModuleUrl) {
     })();
     return await compilerPromise;
 }
-async function loadManifest(nextManifestUrl) {
+function resolveMaxAssetBytes(value) {
+    const resolved = value ?? DEFAULT_MAX_OCAML_ASSET_BYTES;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new TypeError('OCaml runtime maxAssetBytes must be a positive safe integer');
+    }
+    return resolved;
+}
+function assertManifestAssetLimit(manifest, limit) {
+    const declaredAssets = [
+        ['findlib.conf', manifest.findlibConf?.bytes],
+        ['ocamlc', manifest.tools?.ocamlc?.bytes],
+        ['js_of_ocaml', manifest.tools?.js_of_ocaml?.bytes],
+        ['wasm_of_ocaml', manifest.tools?.wasm_of_ocaml?.bytes],
+        ...Object.entries(manifest.binaryenTools || {}).map(([name, asset]) => [name, asset?.bytes]),
+        ...(manifest.runtimePack
+            ? [
+                ['runtime pack index', manifest.runtimePack.indexBytes],
+                [
+                    'runtime pack compressed payload',
+                    manifest.runtimePack.compressedBytes
+                ],
+                ['runtime pack expanded payload', manifest.runtimePack.totalBytes]
+            ]
+            : []),
+        ...(manifest.ocamlLibFiles || []).map((file) => [file.path, file.size]),
+        ...(manifest.packages || []).flatMap((manifestPackage) => (manifestPackage.files || []).map((file) => [file.path, file.size]))
+    ];
+    for (const [label, declaredBytes] of declaredAssets) {
+        if (Number.isSafeInteger(declaredBytes) && declaredBytes > limit) {
+            throw new Error(`OCaml runtime asset ${label} exceeds the ${limit} byte limit`);
+        }
+    }
+}
+async function loadManifest(nextManifestUrl, nextReceipt, nextMaxAssetBytes) {
     if (!nextManifestUrl) {
         throw new Error('OCaml runtime is not configured. Set runtimeAssets.ocaml.moduleUrl and runtimeAssets.ocaml.manifestUrl or sync the bundled wasm-of-js-of-ocaml assets.');
     }
-    if (loadedManifestUrl === nextManifestUrl && manifestPromise) {
+    const manifestLimit = Math.min(MAX_OCAML_MANIFEST_BYTES, nextMaxAssetBytes);
+    if (nextReceipt.bytes > manifestLimit) {
+        throw new Error(`OCaml manifest exceeds the ${manifestLimit} byte limit`);
+    }
+    const identity = outerAssetIdentity(nextManifestUrl, nextReceipt);
+    if (loadedManifestIdentity === identity &&
+        loadedManifestMaxAssetBytes === nextMaxAssetBytes &&
+        manifestPromise) {
         return await manifestPromise;
     }
-    loadedManifestUrl = nextManifestUrl;
+    loadedManifestIdentity = identity;
+    loadedManifestMaxAssetBytes = nextMaxAssetBytes;
     compiledResult = null;
     compiledCacheKey = '';
     manifestPromise = (async () => {
-        const response = await fetch(nextManifestUrl, { cache: 'no-store' });
-        if (!response.ok) {
-            throw new Error(`failed to fetch OCaml manifest: ${response.status}`);
+        const bytes = await fetchRuntimeAssetBytes({
+            url: nextManifestUrl,
+            label: 'OCaml manifest',
+            cache: 'no-store',
+            maxAssetBytes: nextReceipt.bytes
+        });
+        await verifyRuntimeAssetIntegrity({
+            asset: nextManifestUrl,
+            bytes,
+            expected: nextReceipt,
+            runtimeId: 'OCAML'
+        });
+        let manifest;
+        try {
+            manifest = JSON.parse(textDecoder.decode(bytes));
+        }
+        catch {
+            throw new Error('OCaml manifest is not valid JSON');
         }
-        return rewriteManifest((await response.json()), nextManifestUrl);
+        assertManifestAssetLimit(manifest, nextMaxAssetBytes);
+        return rewriteManifest(manifest, nextManifestUrl);
     })();
     return await manifestPromise;
 }
@@ -122,7 +246,7 @@ function getJsArtifact(result) {
     }
     return programArtifact;
 }
-async function executeCompileResult(result, log = false) {
+async function executeCompileResult(result, log = false, stdin) {
     const programArtifact = getJsArtifact(result);
     const assetFiles = result.artifacts.filter((artifact) => artifact.kind === 'wasm' || artifact.kind === 'asset');
     const assetResolverKey = '__wasm_of_js_of_ocaml_resolve_asset';
@@ -131,7 +255,8 @@ async function executeCompileResult(result, log = false) {
     const sourceDir = programArtifact.path.replace(/\/[^/]+$/, '');
     const createdObjectUrls = [];
     const stdinEncoder = new TextEncoder();
-    let stdinChunkOcaml = new Uint8Array(0);
+    const hasExplicitStdinOcaml = typeof stdin === 'string';
+    let stdinChunkOcaml = hasExplicitStdinOcaml ? stdinEncoder.encode(stdin) : new Uint8Array(0);
     let stdinChunkOffsetOcaml = 0;
     const originalConsole = globalThis.console;
     const originalFetch = globalThis.fetch.bind(globalThis);
@@ -145,11 +270,11 @@ async function executeCompileResult(result, log = false) {
     const hadModule = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'module');
     const hadExports = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'exports');
     const hadFs = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'fs');
-    const originalProcess = runtimeGlobal.process;
-    const originalRequire = runtimeGlobal.require;
-    const originalModule = runtimeGlobal.module;
-    const originalExports = runtimeGlobal.exports;
-    const originalFs = runtimeGlobal.fs;
+    const originalProcess = runtimeGlobal['process'];
+    const originalRequire = runtimeGlobal['require'];
+    const originalModule = runtimeGlobal['module'];
+    const originalExports = runtimeGlobal['exports'];
+    const originalFs = runtimeGlobal['fs'];
     const hadStdinHook = Object.prototype.hasOwnProperty.call(runtimeGlobal, stdinHookKey);
     const originalStdinHook = runtimeGlobal[stdinHookKey];
     const assetEntries = assetFiles
@@ -199,6 +324,8 @@ async function executeCompileResult(result, log = false) {
             return new Uint8Array(0);
         }
         while (stdinChunkOffsetOcaml >= stdinChunkOcaml.length) {
+            if (hasExplicitStdinOcaml)
+                return null;
             const chunk = waitForBufferedStdin(stdinBufferOcaml, () => postMessage({ buffer: true }));
             if (chunk == null) {
                 stdinChunkOcaml = new Uint8Array(0);
@@ -257,7 +384,7 @@ async function executeCompileResult(result, log = false) {
         }
         return await originalFetch(input, init);
     });
-    runtimeGlobal.process = undefined;
+    runtimeGlobal['process'] = undefined;
     runtimeGlobal[stdinHookKey] = (requestedBytes = Number.MAX_SAFE_INTEGER) => {
         const encoded = readOcamlStdinBytes(requestedBytes);
         if (encoded == null) {
@@ -282,15 +409,15 @@ async function executeCompileResult(result, log = false) {
             return encoded.byteLength;
         }
     };
-    runtimeGlobal.fs = stdinFsShim;
-    runtimeGlobal.require = (specifier) => {
+    runtimeGlobal['fs'] = stdinFsShim;
+    runtimeGlobal['require'] = (specifier) => {
         if (specifier === 'fs' || specifier === 'node:fs') {
             return stdinFsShim;
         }
         throw new Error(`unsupported OCaml runtime require: ${specifier}`);
     };
-    runtimeGlobal.module = { exports: {} };
-    runtimeGlobal.exports = runtimeGlobal.module.exports;
+    runtimeGlobal['module'] = { exports: {} };
+    runtimeGlobal['exports'] = runtimeGlobal['module'].exports;
     try {
         let normalizedSource = normalizeAssetLoader(programArtifact.data, runtimePromiseKey);
         const stdinReadReplacement = 'read($1,$2,$3,$4){var e=globalThis.__wasmIdleOcamlReadStdin?globalThis.__wasmIdleOcamlReadStdin($3):null;if(e==null)return 0;var h=e.length,f=new Uint8Array(h),i=0;for(;i<h;i++)f[i]=e.charCodeAt(i);var g=f.length<$3?f.length:$3;$1.set(f.subarray(0,g),$2);return g}';
@@ -322,34 +449,34 @@ async function executeCompileResult(result, log = false) {
         delete globalThis[runtimePromiseKey];
         delete globalThis[assetResolverKey];
         if (!hadProcess) {
-            delete runtimeGlobal.process;
+            delete runtimeGlobal['process'];
         }
         else {
-            runtimeGlobal.process = originalProcess;
+            runtimeGlobal['process'] = originalProcess;
         }
         if (!hadRequire) {
-            delete runtimeGlobal.require;
+            delete runtimeGlobal['require'];
         }
         else {
-            runtimeGlobal.require = originalRequire;
+            runtimeGlobal['require'] = originalRequire;
         }
         if (!hadModule) {
-            delete runtimeGlobal.module;
+            delete runtimeGlobal['module'];
         }
         else {
-            runtimeGlobal.module = originalModule;
+            runtimeGlobal['module'] = originalModule;
         }
         if (!hadExports) {
-            delete runtimeGlobal.exports;
+            delete runtimeGlobal['exports'];
         }
         else {
-            runtimeGlobal.exports = originalExports;
+            runtimeGlobal['exports'] = originalExports;
         }
         if (!hadFs) {
-            delete runtimeGlobal.fs;
+            delete runtimeGlobal['fs'];
         }
         else {
-            runtimeGlobal.fs = originalFs;
+            runtimeGlobal['fs'] = originalFs;
         }
         if (!hadStdinHook) {
             delete runtimeGlobal[stdinHookKey];
@@ -363,39 +490,60 @@ async function executeCompileResult(result, log = false) {
     }
 }
 self.onmessage = async (event) => {
-    const { load, moduleUrl: nextModuleUrl, manifestUrl: nextManifestUrl, code, prepare, target = 'wasm', wasmBinaryenMode = 'fast', log = true, buffer } = event.data;
+    let log = true;
     try {
-        if (load) {
-            moduleUrl = nextModuleUrl;
-            manifestUrl = nextManifestUrl;
-            await Promise.all([loadCompiler(moduleUrl), loadManifest(manifestUrl)]);
+        if (event.data.load) {
+            moduleUrl = event.data.moduleUrl;
+            manifestUrl = event.data.manifestUrl;
+            moduleReceipt = requireOuterAssetReceipt(event.data.moduleReceipt, 'module');
+            manifestReceipt = requireOuterAssetReceipt(event.data.manifestReceipt, 'manifest');
+            maxAssetBytes = resolveMaxAssetBytes(event.data.maxAssetBytes);
+            await loadManifest(manifestUrl, manifestReceipt, maxAssetBytes);
+            await loadCompiler(moduleUrl, moduleReceipt, maxAssetBytes);
             postMessage({ load: true });
             return;
         }
+        const { code, prepare, target = 'wasm', wasmBinaryenMode = 'fast', log: configuredLog = true, buffer, stdin, activePath = 'main.ml', workspaceFiles = [] } = event.data;
+        log = configuredLog;
         stdinBufferOcaml = buffer ? new Int32Array(buffer) : null;
         if (log) {
             console.log(`[wasm-idle:ocaml-worker] compile start prepare=${prepare} target=${target} binaryen=${wasmBinaryenMode}`);
         }
         postMessage({ progress: { stage: 'compile-bootstrap', percent: 10 } });
-        const [compilerModule, manifest] = await Promise.all([
-            loadCompiler(moduleUrl),
-            loadManifest(manifestUrl)
-        ]);
+        if (!moduleReceipt || !manifestReceipt) {
+            throw new Error('OCaml runtime outer asset receipts are not loaded');
+        }
+        const manifest = await loadManifest(manifestUrl, manifestReceipt, maxAssetBytes);
+        const compilerModule = await loadCompiler(moduleUrl, moduleReceipt, maxAssetBytes);
         postMessage({ progress: { stage: 'compile-ready', percent: 25 } });
-        const compileKey = `${target}\n${wasmBinaryenMode}\n${code}`;
+        const files = Object.fromEntries([
+            ...workspaceFiles.map((file) => [file.path, file.content]),
+            [activePath, code]
+        ]);
+        const compileKey = JSON.stringify({
+            target,
+            wasmBinaryenMode,
+            entry: activePath,
+            files
+        });
         let compiledFresh = false;
         if (!compiledResult || compiledCacheKey !== compileKey) {
             const result = await compilerModule.compile({
-                files: {
-                    'main.ml': code
-                },
-                entry: 'main.ml',
+                files,
+                entry: activePath,
                 target,
                 effectsMode: 'cps',
                 wasmBinaryenMode
             }, {
                 system: compilerModule.createBrowserWorkerSystemDispatcher({
-                    manifest
+                    manifest,
+                    runtimeAssets: {
+                        limits: {
+                            maxAssetBytes,
+                            maxMetadataBytes: Math.min(MAX_OCAML_MANIFEST_BYTES, maxAssetBytes),
+                            maxEntryBytes: Math.min(MAX_OCAML_RUNTIME_ENTRY_BYTES, maxAssetBytes)
+                        }
+                    }
                 }),
                 toolchainRoot: '/static/toolchain'
             });
@@ -439,7 +587,7 @@ self.onmessage = async (event) => {
             return;
         }
         postMessage({ progress: { stage: 'runtime-start', percent: 95 } });
-        await executeCompileResult(result, log);
+        await executeCompileResult(result, log, stdin);
     }
     catch (error) {
         if (log) {

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

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