wasm-idle 0.7.2 → 1.0.0

package/dist/playground/assets.js

@@ -1,185 +1,158 @@
-import { env as publicEnv } from '$env/dynamic/public';
+import { env as dynamicPublicEnv } from '$env/dynamic/public';
+import { BUNDLED_CLANG_ASSET_INTEGRITY } from './clangAssetIntegrity';
+import { snapshotDOuterAssetConfig } from './dOuterAssets';
+import { snapshotFortranExecutionAssetReceipts } from './fortranAssets';
 import { normalizeTeaVmBaseUrl, resolveTeaVmBaseUrl } from './teavmConfig';
+import { WASM_GLEAM_ASSET_VERSION, WASM_GLEAM_RUNNER_RECEIPT } from './wasmGleamVersion';
+import { WASM_FORTH_ASSET_VERSION, WASM_FORTH_RUNTIME_PROFILE, WASM_FORTH_RUNNER_RECEIPT } from './wasmForthVersion';
+import { WASM_BQN_ASSET_VERSION, WASM_BQN_RUNTIME_PROFILE, WASM_BQN_RUNNER_RECEIPT } from './wasmBqnVersion';
+import { WASM_BASH_RUNTIME_BUNDLE } from './wasmBashVersion';
+import { WASM_CLOJURESCRIPT_ASSET_VERSION, WASM_CLOJURESCRIPT_RUNNER_RECEIPT, WASM_CLOJURESCRIPT_RUNTIME_PROFILE } from './wasmClojureScriptVersion';
+import { WASM_J_ASSET_VERSION, WASM_J_RUNNER_RECEIPT, WASM_J_RUNTIME_PROFILE } from './wasmJVersion';
+import { WASM_JANET_RUNTIME_BUNDLE } from './wasmJanetVersion';
+import { WASM_JULIA_RUNTIME_BUNDLE } from './wasmJuliaVersion';
+import { WASM_LISP_ASSET_VERSION } from './wasmLispVersion';
+import { WASM_NIM_RUNTIME_BUNDLE } from './wasmNimVersion';
+import { WASM_PASCAL_RUNTIME_BUNDLE } from './wasmPascalVersion';
+import { WASM_AWK_RUNTIME_BUNDLE } from './wasmAwkVersion';
+import { WASM_PROLOG_ASSET_VERSION, WASM_PROLOG_RUNNER_RECEIPT, WASM_PROLOG_RUNTIME_PROFILE } from './wasmPrologVersion';
+import { WASM_PERL_RUNTIME_BUNDLE } from './wasmPerlVersion';
+import { WASM_TCL_RUNTIME_BUNDLE } from './wasmTclVersion';
+import { WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE } from './wasmTinyGoVersion';
+import { WASM_OBJECTIVEC_ASSET_RECEIPTS } from './wasmObjectiveCVersion';
+import { WASM_DEBUG_RUNTIME_PROFILE } from './wasmDebugVersion';
+import { RUBY_RUNTIME_BUNDLE, RUBY_RUNTIME_MANIFEST_PATH, RUBY_RUNTIME_MODULE_STORAGE_PATH, RUBY_RUNTIME_WASM_STORAGE_PATH, TEAVM_RUNTIME_ASSET_NAMES, TEAVM_RUNTIME_ASSET_RECEIPTS, RuntimeConfigurationError, snapshotBashRuntimePreflightProfile, snapshotAwkRuntimePreflightProfile, snapshotJanetRuntimePreflightProfile, snapshotJuliaRuntimePreflightProfile, snapshotNimRuntimePreflightProfile, snapshotPascalRuntimePreflightProfile, snapshotPerlRuntimePreflightProfile, snapshotPrologRuntimePreflightProfile, snapshotRubyRuntimePreflightProfile, snapshotTclRuntimePreflightProfile, snapshotTeaVmRuntimeAssetReceipts } from '@wasm-idle/core';
+import { WASM_FORTRAN_EXECUTION_ASSET_RECEIPTS } from './wasmFortranExecutionAssets';
+import { WASM_D_OUTER_ASSET_RECEIPTS } from './wasmDIntegrity';
+import { WASM_ZIG_ASSET_RECEIPTS } from './wasmZigVersion';
+import { snapshotZigExecutionAssetReceipts } from './zigAssets';
+const publicEnv = (dynamicPublicEnv || {});
 export const PYTHON_RUNTIME_LOAD_ASSETS = [
+    'pyodide.mjs',
     'pyodide.asm.js',
     'pyodide-lock.json',
     'pyodide.asm.wasm',
     'python_stdlib.zip'
 ];
-export const JAVA_RUNTIME_LOAD_ASSETS = [
-    'compiler.wasm-runtime.js',
-    'compiler.wasm',
-    'compile-classlib-teavm.bin',
-    'runtime-classlib-teavm.bin'
-];
+export const JAVA_RUNTIME_LOAD_ASSETS = TEAVM_RUNTIME_ASSET_NAMES;
 export const CLANG_RUNTIME_LOAD_ASSETS = [
-    'bin/memfs.zip',
-    'bin/clang.zip',
-    'bin/lld.zip',
-    'bin/sysroot.tar.zip'
+    'runtime-manifest.v1.json',
+    'bin/memfs.wasm.gz',
+    'bin/clang.wasm.gz',
+    'bin/lld.wasm.gz',
+    'bin/sysroot.tar.gz'
 ];
 export const CLANGD_RUNTIME_LOAD_ASSETS = ['clangd.js', 'clangd.wasm.gz'];
-const PYTHON_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/python/';
-const JAVA_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/java/';
-const CLANG_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/clang/';
-const CLANGD_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/clangd/';
+export const RUNTIME_LOAD_ASSETS = {
+    python: PYTHON_RUNTIME_LOAD_ASSETS,
+    java: JAVA_RUNTIME_LOAD_ASSETS,
+    clang: CLANG_RUNTIME_LOAD_ASSETS,
+    clangd: CLANGD_RUNTIME_LOAD_ASSETS
+};
 const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
     const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
     return currentUrl ? new URL(normalized, currentUrl).href : normalized;
 };
 const resolveConfiguredUrl = (url, currentUrl = '') => currentUrl ? new URL(url, currentUrl).href : url;
-const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
-const resolvePythonBaseUrl = (rootUrl = '', currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}/pyodide/`, currentUrl);
-const resolvePythonRuntimeAssetConfig = (options, currentUrl = '') => {
-    if (typeof options === 'string') {
-        return {
-            baseUrl: resolvePythonBaseUrl(options, currentUrl),
-            useAssetBridge: false
-        };
-    }
-    const runtimeConfig = options?.python;
-    if (runtimeConfig?.baseUrl) {
-        return {
-            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
-            loader: runtimeConfig.loader,
-            useAssetBridge: !!runtimeConfig.loader
-        };
-    }
-    if (options?.rootUrl) {
-        return {
-            baseUrl: resolvePythonBaseUrl(options.rootUrl, currentUrl),
-            loader: runtimeConfig?.loader,
-            useAssetBridge: !!runtimeConfig?.loader
-        };
+const resolveAllowedBaseUrls = (urls, currentUrl = '') => urls?.map((url) => normalizeBaseUrl(url, currentUrl));
+const useAssetBridgeForConfig = (config, integrity = config?.integrity) => !!config?.loader || !!integrity || !!config?.allowedBaseUrls?.length;
+const resolveRuntimeAssetIntegrity = (runtime, config) => {
+    if (runtime === 'java') {
+        return snapshotTeaVmRuntimeAssetReceipts(config?.integrity === undefined ? TEAVM_RUNTIME_ASSET_RECEIPTS : config.integrity);
     }
-    if (runtimeConfig?.loader) {
-        return {
-            baseUrl: PYTHON_VIRTUAL_BASE_URL,
-            loader: runtimeConfig.loader,
-            useAssetBridge: true
-        };
+    if (config?.integrity)
+        return config.integrity;
+    if (runtime === 'clang' && !config?.baseUrl && !config?.loader) {
+        return BUNDLED_CLANG_ASSET_INTEGRITY;
     }
-    return {
-        baseUrl: resolvePythonBaseUrl('', currentUrl),
-        useAssetBridge: false
-    };
+    return undefined;
 };
-const resolveJavaBaseUrl = (rootUrl = '', currentUrl = '') => resolveTeaVmBaseUrl(rootUrl, currentUrl);
-const resolveJavaRuntimeAssetConfig = (options, currentUrl = '') => {
-    if (typeof options === 'string') {
-        return {
-            baseUrl: resolveJavaBaseUrl(options, currentUrl),
-            useAssetBridge: false
-        };
-    }
-    const runtimeConfig = options?.java;
-    if (runtimeConfig?.baseUrl) {
-        return {
-            baseUrl: currentUrl
-                ? new URL(normalizeTeaVmBaseUrl(runtimeConfig.baseUrl), currentUrl).href
-                : normalizeTeaVmBaseUrl(runtimeConfig.baseUrl),
-            loader: runtimeConfig.loader,
-            useAssetBridge: !!runtimeConfig.loader
-        };
-    }
-    if (options?.rootUrl) {
-        return {
-            baseUrl: resolveJavaBaseUrl(options.rootUrl, currentUrl),
-            loader: runtimeConfig?.loader,
-            useAssetBridge: !!runtimeConfig?.loader
-        };
-    }
-    if (runtimeConfig?.loader) {
-        return {
-            baseUrl: JAVA_VIRTUAL_BASE_URL,
-            loader: runtimeConfig.loader,
-            useAssetBridge: true
-        };
+const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
+const resolveFolderRuntimeBaseUrl = (folder, rootUrl = '', currentUrl = '') => normalizeBaseUrl(rootUrl ? `${normalizeRootUrl(rootUrl) || ''}/${folder}/` : `${folder}/`, currentUrl);
+const normalizeTeaVmConfiguredBaseUrl = (baseUrl, currentUrl = '') => currentUrl
+    ? new URL(normalizeTeaVmBaseUrl(baseUrl), currentUrl).href
+    : normalizeTeaVmBaseUrl(baseUrl);
+const RUNTIME_ASSET_FOLDERS = {
+    python: {
+        folder: 'pyodide',
+        virtualBaseUrl: 'https://wasm-idle.invalid/python/'
+    },
+    java: {
+        folder: 'teavm',
+        virtualBaseUrl: 'https://wasm-idle.invalid/java/',
+        resolveRootBaseUrl: (rootUrl, currentUrl) => {
+            const configuredBaseUrl = (publicEnv.PUBLIC_TEAVM_BASE_URL || '').trim();
+            return configuredBaseUrl || rootUrl
+                ? resolveTeaVmBaseUrl(rootUrl, currentUrl, configuredBaseUrl)
+                : normalizeBaseUrl('teavm/', currentUrl);
+        },
+        resolveConfiguredBaseUrl: normalizeTeaVmConfiguredBaseUrl
+    },
+    clang: {
+        folder: 'clang',
+        virtualBaseUrl: 'https://wasm-idle.invalid/clang/'
+    },
+    clangd: {
+        folder: 'clangd',
+        virtualBaseUrl: 'https://wasm-idle.invalid/clangd/'
     }
-    return {
-        baseUrl: resolveJavaBaseUrl('', currentUrl),
-        useAssetBridge: false
-    };
 };
-const resolveClangRuntimeAssetConfig = (options, currentUrl = '') => {
+const resolveRuntimeRootBaseUrl = (config, rootUrl = '', currentUrl = '') => config.resolveRootBaseUrl?.(rootUrl, currentUrl) ||
+    resolveFolderRuntimeBaseUrl(config.folder, rootUrl, currentUrl);
+const resolveRuntimeConfiguredBaseUrl = (config, baseUrl, currentUrl = '') => config.resolveConfiguredBaseUrl?.(baseUrl, currentUrl) || normalizeBaseUrl(baseUrl, currentUrl);
+export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
+    const runtimeFolder = RUNTIME_ASSET_FOLDERS[runtime];
     if (typeof options === 'string') {
+        const integrity = resolveRuntimeAssetIntegrity(runtime, undefined);
         return {
-            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/clang/`, currentUrl),
-            useAssetBridge: false
+            baseUrl: resolveRuntimeRootBaseUrl(runtimeFolder, options, currentUrl),
+            ...(integrity ? { integrity } : {}),
+            useAssetBridge: !!integrity
         };
     }
-    const runtimeConfig = options?.clang;
+    const runtimeConfig = options?.[runtime];
+    const integrity = resolveRuntimeAssetIntegrity(runtime, runtimeConfig);
+    const allowedBaseUrls = resolveAllowedBaseUrls(runtimeConfig?.allowedBaseUrls, currentUrl);
     if (runtimeConfig?.baseUrl) {
         return {
-            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
+            baseUrl: resolveRuntimeConfiguredBaseUrl(runtimeFolder, runtimeConfig.baseUrl, currentUrl),
             loader: runtimeConfig.loader,
-            useAssetBridge: !!runtimeConfig.loader
+            integrity,
+            allowedBaseUrls,
+            useAssetBridge: useAssetBridgeForConfig(runtimeConfig, integrity)
         };
     }
     if (options?.rootUrl) {
         return {
-            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/clang/`, currentUrl),
+            baseUrl: resolveRuntimeRootBaseUrl(runtimeFolder, options.rootUrl, currentUrl),
             loader: runtimeConfig?.loader,
-            useAssetBridge: !!runtimeConfig?.loader
+            integrity,
+            allowedBaseUrls,
+            useAssetBridge: useAssetBridgeForConfig(runtimeConfig, integrity)
         };
     }
     if (runtimeConfig?.loader) {
         return {
-            baseUrl: CLANG_VIRTUAL_BASE_URL,
+            baseUrl: runtimeFolder.virtualBaseUrl,
             loader: runtimeConfig.loader,
+            integrity,
+            allowedBaseUrls,
             useAssetBridge: true
         };
     }
-    return {
-        baseUrl: normalizeBaseUrl('/clang/', currentUrl),
-        useAssetBridge: false
-    };
-};
-const resolveClangdRuntimeAssetConfig = (options, currentUrl = '') => {
-    if (typeof options === 'string') {
-        return {
-            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/clangd/`, currentUrl),
-            useAssetBridge: false
-        };
-    }
-    const runtimeConfig = options?.clangd;
-    if (runtimeConfig?.baseUrl) {
-        return {
-            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
-            loader: runtimeConfig.loader,
-            useAssetBridge: !!runtimeConfig.loader
-        };
-    }
-    if (options?.rootUrl) {
-        return {
-            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/clangd/`, currentUrl),
-            loader: runtimeConfig?.loader,
-            useAssetBridge: !!runtimeConfig?.loader
-        };
-    }
-    if (runtimeConfig?.loader) {
+    if (runtimeConfig?.integrity || runtimeConfig?.allowedBaseUrls?.length) {
         return {
-            baseUrl: CLANGD_VIRTUAL_BASE_URL,
-            loader: runtimeConfig.loader,
+            baseUrl: resolveRuntimeRootBaseUrl(runtimeFolder, '', currentUrl),
+            integrity,
+            allowedBaseUrls,
             useAssetBridge: true
         };
     }
     return {
-        baseUrl: normalizeBaseUrl('/clangd/', currentUrl),
-        useAssetBridge: false
+        baseUrl: resolveRuntimeRootBaseUrl(runtimeFolder, '', currentUrl),
+        ...(integrity ? { integrity } : {}),
+        useAssetBridge: !!integrity
     };
-};
-export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
-    switch (runtime) {
-        case 'python':
-            return resolvePythonRuntimeAssetConfig(options, currentUrl);
-        case 'java':
-            return resolveJavaRuntimeAssetConfig(options, currentUrl);
-        case 'clang':
-            return resolveClangRuntimeAssetConfig(options, currentUrl);
-        case 'clangd':
-            return resolveClangdRuntimeAssetConfig(options, currentUrl);
-    }
 }
 export function resolveRustCompilerUrl(options, currentUrl = '') {
     const configuredCompilerUrl = (typeof options === 'object' && options?.rust?.compilerUrl) ||
@@ -188,6 +161,58 @@ export function resolveRustCompilerUrl(options, currentUrl = '') {
         return '';
     return currentUrl ? new URL(configuredCompilerUrl, currentUrl).href : configuredCompilerUrl;
 }
+export function resolveDebugRuntimeUrls(options, currentUrl = '') {
+    const configuredDebug = typeof options === 'object' ? options?.debug : undefined;
+    const publicBaseUrl = (publicEnv.PUBLIC_WASM_DEBUG_RUNTIME_URL || '').trim();
+    const configuredBaseUrl = configuredDebug?.baseUrl || publicBaseUrl;
+    const rootUrl = (typeof options === 'string' ? options : options?.rootUrl) || '';
+    const bundledBaseUrl = resolveFolderRuntimeBaseUrl('wasm-debug', rootUrl, currentUrl);
+    const baseUrl = configuredBaseUrl
+        ? normalizeBaseUrl(configuredBaseUrl, currentUrl)
+        : bundledBaseUrl;
+    const configuredManifestUrl = configuredDebug?.manifestUrl;
+    const manifestUrl = configuredManifestUrl
+        ? resolveConfiguredUrl(configuredManifestUrl, currentUrl)
+        : new URL('runtime-manifest.v2.json', baseUrl).href;
+    const bundledManifestUrl = new URL('runtime-manifest.v2.json', bundledBaseUrl).href;
+    const explicitManifestSha256 = (configuredDebug
+        ? configuredDebug.manifestSha256
+        : publicEnv.PUBLIC_WASM_DEBUG_RUNTIME_MANIFEST_SHA256)?.trim();
+    const manifestReceipt = explicitManifestSha256
+        ? Object.freeze({ sha256: explicitManifestSha256 })
+        : baseUrl === bundledBaseUrl && manifestUrl === bundledManifestUrl
+            ? WASM_DEBUG_RUNTIME_PROFILE.manifestReceipt
+            : undefined;
+    return {
+        baseUrl,
+        manifestUrl,
+        manifestReceipt
+    };
+}
+export function resolveRustDebugModuleUrl(options, currentUrl = '') {
+    const configuredDebugModuleUrl = typeof options === 'object' ? options?.rust?.debugModuleUrl : undefined;
+    if (configuredDebugModuleUrl) {
+        return currentUrl
+            ? new URL(configuredDebugModuleUrl, currentUrl).href
+            : configuredDebugModuleUrl;
+    }
+    const compilerUrl = resolveRustCompilerUrl(options, currentUrl);
+    if (!compilerUrl)
+        return '';
+    try {
+        const compiler = currentUrl ? new URL(compilerUrl, currentUrl) : new URL(compilerUrl);
+        const debugModule = new URL('./debug-instrumenter.js', compiler);
+        debugModule.search = compiler.search;
+        return debugModule.href;
+    }
+    catch {
+        const queryIndex = compilerUrl.indexOf('?');
+        const path = queryIndex >= 0 ? compilerUrl.slice(0, queryIndex) : compilerUrl;
+        const query = queryIndex >= 0 ? compilerUrl.slice(queryIndex) : '';
+        const slashIndex = path.lastIndexOf('/');
+        return `${slashIndex >= 0 ? path.slice(0, slashIndex + 1) : ''}debug-instrumenter.js${query}`;
+    }
+}
 export function resolveGoCompilerUrl(options, currentUrl = '') {
     const configuredCompilerUrl = (typeof options === 'object' && options?.go?.compilerUrl) ||
         (publicEnv.PUBLIC_WASM_GO_COMPILER_URL || '').trim();
@@ -195,6 +220,57 @@ export function resolveGoCompilerUrl(options, currentUrl = '') {
         return '';
     return currentUrl ? new URL(configuredCompilerUrl, currentUrl).href : configuredCompilerUrl;
 }
+export function resolveDModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.d?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_D_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-d/index.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-d/index.js`, currentUrl);
+    }
+    return '';
+}
+export function resolveDRuntimeAssetConfig(options, currentUrl = '') {
+    const moduleUrl = resolveDModuleUrl(options, currentUrl);
+    if (!moduleUrl) {
+        throw new TypeError('D runtime is not configured. Set PUBLIC_WASM_D_MODULE_URL or runtimeAssets.d.moduleUrl.');
+    }
+    const configuredManifestUrl = (typeof options === 'object' && options?.d?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_D_MANIFEST_URL || '').trim();
+    let manifestUrl;
+    if (configuredManifestUrl) {
+        manifestUrl = resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    else {
+        const module = new URL(moduleUrl);
+        const manifest = new URL('runtime/runtime-manifest.v1.json', module);
+        manifest.search = module.search;
+        manifestUrl = manifest.href;
+    }
+    return snapshotDOuterAssetConfig({
+        moduleUrl,
+        manifestUrl,
+        integrity: (typeof options === 'object' && options?.d?.integrity) || WASM_D_OUTER_ASSET_RECEIPTS
+    });
+}
+export function resolveDotnetModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.dotnet?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_DOTNET_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-dotnet/index.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-dotnet/index.js`, currentUrl);
+    }
+    return '';
+}
 export function resolveOcamlModuleUrl(options, currentUrl = '') {
     const configuredModuleUrl = (typeof options === 'object' && options?.ocaml?.moduleUrl) ||
         (publicEnv.PUBLIC_WASM_OCAML_MODULE_URL || '').trim();
@@ -251,51 +327,92 @@ function deriveTinyGoModuleUrlFromAppUrl(appUrl, currentUrl = '') {
     const [withoutQuery, query = ''] = withoutHash.split('?', 2);
     let moduleUrlPath = withoutQuery;
     if (moduleUrlPath.endsWith('/index.html')) {
-        moduleUrlPath = `${moduleUrlPath.slice(0, -'index.html'.length)}runtime.js`;
+        moduleUrlPath = `${moduleUrlPath.slice(0, -'index.html'.length)}upstream.js`;
     }
     else if (moduleUrlPath.endsWith('/')) {
-        moduleUrlPath = `${moduleUrlPath}runtime.js`;
+        moduleUrlPath = `${moduleUrlPath}upstream.js`;
     }
     else {
-        moduleUrlPath = `${moduleUrlPath.replace(/\/$/, '')}/runtime.js`;
+        moduleUrlPath = `${moduleUrlPath.replace(/\/$/, '')}/upstream.js`;
     }
     return `${moduleUrlPath}${query ? `?${query}` : ''}${hash ? `#${hash}` : ''}`;
 }
+function pinTinyGoExecutableModuleUrl(moduleUrl, currentUrl = '') {
+    const entryReceipt = WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE.modules[WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE.entryPath];
+    if (!entryReceipt) {
+        throw new RuntimeConfigurationError('TinyGo executable graph entry receipt is missing', {
+            phase: 'asset',
+            runtimeId: 'TINYGO'
+        });
+    }
+    let parsed;
+    try {
+        parsed = currentUrl ? new URL(moduleUrl, currentUrl) : new URL(moduleUrl);
+    }
+    catch {
+        // Relative URLs without a current document stay relative until browser resolution.
+    }
+    if (parsed?.protocol === 'http:' || parsed?.protocol === 'https:') {
+        if (parsed.username || parsed.password || parsed.hash) {
+            throw new RuntimeConfigurationError('TinyGo executable module URL is unsafe', {
+                phase: 'asset',
+                runtimeId: 'TINYGO'
+            });
+        }
+        const receiptQuery = `?v=${entryReceipt.sha256}`;
+        if (parsed.search && parsed.search !== receiptQuery) {
+            throw new RuntimeConfigurationError('TinyGo executable module URL must use its exact receipt query pin', { phase: 'asset', runtimeId: 'TINYGO' });
+        }
+        parsed.search = receiptQuery;
+        return parsed.href;
+    }
+    if (!parsed) {
+        const [withoutHash, hash = ''] = moduleUrl.split('#', 2);
+        const [withoutQuery, query = ''] = withoutHash.split('?', 2);
+        if (hash || (query && query !== `v=${entryReceipt.sha256}`)) {
+            throw new RuntimeConfigurationError('TinyGo executable module URL must use its exact receipt query pin', { phase: 'asset', runtimeId: 'TINYGO' });
+        }
+        return `${withoutQuery}?v=${entryReceipt.sha256}`;
+    }
+    return moduleUrl;
+}
 export function resolveTinyGoModuleUrl(options, currentUrl = '') {
     const configuredModuleUrl = (typeof options === 'object' && options?.tinygo?.moduleUrl) ||
         (publicEnv.PUBLIC_WASM_TINYGO_MODULE_URL || '').trim();
     if (configuredModuleUrl) {
-        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+        return pinTinyGoExecutableModuleUrl(resolveConfiguredUrl(configuredModuleUrl, currentUrl), currentUrl);
     }
     const configuredLegacyAppUrl = (typeof options === 'object' && options?.tinygo?.appUrl) ||
         (publicEnv.PUBLIC_WASM_TINYGO_APP_URL || '').trim();
     if (configuredLegacyAppUrl) {
-        return deriveTinyGoModuleUrlFromAppUrl(configuredLegacyAppUrl, currentUrl);
+        return pinTinyGoExecutableModuleUrl(deriveTinyGoModuleUrlFromAppUrl(configuredLegacyAppUrl, currentUrl), currentUrl);
     }
     if (typeof options === 'string') {
-        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-tinygo/runtime.js`, currentUrl);
+        return pinTinyGoExecutableModuleUrl(resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-tinygo/upstream.js`, currentUrl), currentUrl);
     }
     if (options?.rootUrl) {
-        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-tinygo/runtime.js`, currentUrl);
+        return pinTinyGoExecutableModuleUrl(resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-tinygo/upstream.js`, currentUrl), currentUrl);
     }
     return '';
 }
-export function resolveTinyGoHostCompileUrls(options, currentUrl = '') {
-    if (typeof options === 'object' && options?.tinygo?.disableHostCompile) {
-        return [];
+export function resolveElixirBundleUrl(options, currentUrl = '') {
+    const configuredBundleUrl = (typeof options === 'object' && options?.elixir?.bundleUrl) ||
+        (publicEnv.PUBLIC_WASM_ELIXIR_BUNDLE_URL || '').trim();
+    if (configuredBundleUrl) {
+        return resolveConfiguredUrl(configuredBundleUrl, currentUrl);
     }
-    const configuredHostCompileUrl = (typeof options === 'object' && options?.tinygo?.hostCompileUrl) ||
-        (publicEnv.PUBLIC_WASM_TINYGO_HOST_COMPILE_URL || '').trim();
-    if (configuredHostCompileUrl) {
-        return [resolveConfiguredUrl(configuredHostCompileUrl, currentUrl)];
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-elixir/bundle.avm`, currentUrl);
     }
-    return [];
-}
-export function resolveTinyGoHostCompileUrl(options, currentUrl = '') {
-    return resolveTinyGoHostCompileUrls(options, currentUrl)[0] || '';
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-elixir/bundle.avm`, currentUrl);
+    }
+    return '';
 }
-export function resolveElixirBundleUrl(options, currentUrl = '') {
-    const configuredBundleUrl = (typeof options === 'object' && options?.elixir?.bundleUrl) ||
+export function resolveErlangBundleUrl(options, currentUrl = '') {
+    const configuredBundleUrl = (typeof options === 'object' && options?.erlang?.bundleUrl) ||
+        (publicEnv.PUBLIC_WASM_ERLANG_BUNDLE_URL || '').trim() ||
+        (typeof options === 'object' && options?.elixir?.bundleUrl) ||
         (publicEnv.PUBLIC_WASM_ELIXIR_BUNDLE_URL || '').trim();
     if (configuredBundleUrl) {
         return resolveConfiguredUrl(configuredBundleUrl, currentUrl);
@@ -308,3 +425,1826 @@ export function resolveElixirBundleUrl(options, currentUrl = '') {
     }
     return '';
 }
+export function resolveTypeScriptModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.typescript?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_TYPESCRIPT_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-typescript/index.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-typescript/index.js`, currentUrl);
+    }
+    return '';
+}
+export function resolveWatModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.wat?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_WAT_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-wat/index.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-wat/index.js`, currentUrl);
+    }
+    return '';
+}
+export function resolveLuaModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.lua?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_LUA_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-lua/index.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-lua/index.js`, currentUrl);
+    }
+    return '';
+}
+export function resolveZigCompilerUrl(options, currentUrl = '') {
+    const configuredCompilerUrl = (typeof options === 'object' && options?.zig?.compilerUrl) ||
+        (publicEnv.PUBLIC_WASM_ZIG_COMPILER_URL || '').trim();
+    if (configuredCompilerUrl) {
+        return resolveConfiguredUrl(configuredCompilerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-zig/zig_small.wasm`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-zig/zig_small.wasm`, currentUrl);
+    }
+    return '';
+}
+export function resolveHaskellModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.haskell?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_HASKELL_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-haskell/dyld.mjs`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-haskell/dyld.mjs`, currentUrl);
+    }
+    return '';
+}
+export function resolveHaskellRootfsUrl(options, currentUrl = '') {
+    const configuredRootfsUrl = (typeof options === 'object' && options?.haskell?.rootfsUrl) ||
+        (publicEnv.PUBLIC_WASM_HASKELL_ROOTFS_URL || '').trim();
+    if (configuredRootfsUrl) {
+        return resolveConfiguredUrl(configuredRootfsUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-haskell/rootfs.tar.zst`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-haskell/rootfs.tar.zst`, currentUrl);
+    }
+    return '';
+}
+export function resolveHaskellBsdtarUrl(options, currentUrl = '') {
+    const configuredBsdtarUrl = (typeof options === 'object' && options?.haskell?.bsdtarUrl) ||
+        (publicEnv.PUBLIC_WASM_HASKELL_BSDTAR_URL || '').trim();
+    if (configuredBsdtarUrl) {
+        return resolveConfiguredUrl(configuredBsdtarUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-haskell/bsdtar.wasm`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-haskell/bsdtar.wasm`, currentUrl);
+    }
+    return '';
+}
+export function resolveFortranBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.fortran?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_FORTRAN_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-fortran/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-fortran/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-fortran/', currentUrl);
+}
+function resolveFortranAssetUrl(options, currentUrl, configKey, envKey, defaultAsset) {
+    const env = publicEnv;
+    const configuredUrl = (typeof options === 'object' && options?.fortran?.[configKey]) ||
+        (env[envKey] || '').trim();
+    if (configuredUrl) {
+        return resolveConfiguredUrl(configuredUrl, currentUrl);
+    }
+    return resolveConfiguredUrl(new URL(defaultAsset, resolveFortranBaseUrl(options, currentUrl)).href, currentUrl);
+}
+export function resolveFortranF2cWasmUrl(options, currentUrl = '') {
+    return resolveFortranAssetUrl(options, currentUrl, 'f2cWasmUrl', 'PUBLIC_WASM_FORTRAN_F2C_WASM_URL', 'f2c.wasm');
+}
+export function resolveFortranLibf2cUrl(options, currentUrl = '') {
+    return resolveFortranAssetUrl(options, currentUrl, 'libf2cUrl', 'PUBLIC_WASM_FORTRAN_LIBF2C_URL', 'libf2c.a');
+}
+export function resolveFortranF2cHeaderUrl(options, currentUrl = '') {
+    return resolveFortranAssetUrl(options, currentUrl, 'f2cHeaderUrl', 'PUBLIC_WASM_FORTRAN_F2C_HEADER_URL', 'f2c.h');
+}
+export function resolveFortranAnalyzerUrl(options, currentUrl = '') {
+    return resolveFortranAssetUrl(options, currentUrl, 'analyzerUrl', 'PUBLIC_WASM_FORTRAN_ANALYZER_URL', 'analyzer.js');
+}
+export function resolveFortranRuntimeAssetConfig(options, currentUrl = '') {
+    const configuredIntegrity = typeof options === 'object' ? options?.fortran?.integrity : undefined;
+    return {
+        baseUrl: resolveFortranBaseUrl(options, currentUrl),
+        f2cWasmUrl: resolveFortranF2cWasmUrl(options, currentUrl),
+        libf2cUrl: resolveFortranLibf2cUrl(options, currentUrl),
+        f2cHeaderUrl: resolveFortranF2cHeaderUrl(options, currentUrl),
+        analyzerUrl: resolveFortranAnalyzerUrl(options, currentUrl),
+        integrity: snapshotFortranExecutionAssetReceipts(configuredIntegrity === undefined
+            ? WASM_FORTRAN_EXECUTION_ASSET_RECEIPTS
+            : configuredIntegrity)
+    };
+}
+export function resolveCobolBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.cobol?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_COBOL_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-cobol/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-cobol/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-cobol/', currentUrl);
+}
+export function resolveObjectiveCBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.objectivec?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_OBJECTIVEC_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-objectivec/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-objectivec/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-objectivec/', currentUrl);
+}
+function resolveObjectiveCAssetUrl(options, currentUrl, configKey, envKey, defaultAsset) {
+    const env = publicEnv;
+    const configuredUrl = (typeof options === 'object' && options?.objectivec?.[configKey]) ||
+        (env[envKey] || '').trim();
+    if (configuredUrl) {
+        return resolveConfiguredUrl(configuredUrl, currentUrl);
+    }
+    return resolveConfiguredUrl(new URL(defaultAsset, resolveObjectiveCBaseUrl(options, currentUrl)).href, currentUrl);
+}
+export function resolveObjectiveCLibobjcUrl(options, currentUrl = '') {
+    return resolveObjectiveCAssetUrl(options, currentUrl, 'libobjcUrl', 'PUBLIC_WASM_OBJECTIVEC_LIBOBJC_URL', 'libobjc.a');
+}
+export function resolveObjectiveCHeadersUrl(options, currentUrl = '') {
+    return resolveObjectiveCAssetUrl(options, currentUrl, 'headersUrl', 'PUBLIC_WASM_OBJECTIVEC_HEADERS_URL', 'headers.json');
+}
+export function resolveObjectiveCLibgnustepBaseUrl(options, currentUrl = '') {
+    return resolveObjectiveCAssetUrl(options, currentUrl, 'libgnustepBaseUrl', 'PUBLIC_WASM_OBJECTIVEC_GNUSTEP_BASE_URL', 'libgnustep-base.a');
+}
+export function resolveObjectiveCLibgnustepBaseObjectUrl(options, currentUrl = '') {
+    return resolveObjectiveCAssetUrl(options, currentUrl, 'libgnustepBaseObjectUrl', 'PUBLIC_WASM_OBJECTIVEC_GNUSTEP_BASE_OBJECT_URL', 'libgnustep-base.o');
+}
+export function resolveObjectiveCFoundationHeadersUrl(options, currentUrl = '') {
+    return resolveObjectiveCAssetUrl(options, currentUrl, 'foundationHeadersUrl', 'PUBLIC_WASM_OBJECTIVEC_FOUNDATION_HEADERS_URL', 'foundation-headers.json');
+}
+export function resolveObjectiveCLibffiUrl(options, currentUrl = '') {
+    return resolveObjectiveCAssetUrl(options, currentUrl, 'libffiUrl', 'PUBLIC_WASM_OBJECTIVEC_LIBFFI_URL', 'libffi.a');
+}
+export function resolveObjectiveCRuntimeAssetConfig(options, currentUrl = '') {
+    const configuredIntegrity = typeof options === 'object' ? options?.objectivec?.integrity : undefined;
+    let integrity = WASM_OBJECTIVEC_ASSET_RECEIPTS;
+    if (configuredIntegrity !== undefined) {
+        if (!configuredIntegrity ||
+            typeof configuredIntegrity !== 'object' ||
+            Array.isArray(configuredIntegrity)) {
+            throw new TypeError('Objective-C runtime asset integrity receipt is required.');
+        }
+        const expectedAssetNames = Object.keys(WASM_OBJECTIVEC_ASSET_RECEIPTS).sort();
+        const receivedAssetNames = Object.keys(configuredIntegrity).sort();
+        if (receivedAssetNames.length !== expectedAssetNames.length ||
+            receivedAssetNames.some((assetName, index) => assetName !== expectedAssetNames[index])) {
+            throw new TypeError('Objective-C runtime asset integrity receipt is incomplete.');
+        }
+        integrity = Object.freeze(Object.fromEntries(expectedAssetNames.map((assetName) => {
+            const receipt = configuredIntegrity[assetName];
+            const bytes = receipt?.bytes;
+            const sha256 = receipt?.sha256;
+            if (!Number.isSafeInteger(bytes) ||
+                bytes <= 0 ||
+                typeof sha256 !== 'string' ||
+                !/^[a-f0-9]{64}$/u.test(sha256)) {
+                throw new TypeError(`Objective-C runtime asset integrity receipt is invalid for ${assetName}.`);
+            }
+            return [assetName, Object.freeze({ bytes: bytes, sha256 })];
+        })));
+    }
+    return {
+        baseUrl: resolveObjectiveCBaseUrl(options, currentUrl),
+        libobjcUrl: resolveObjectiveCLibobjcUrl(options, currentUrl),
+        headersUrl: resolveObjectiveCHeadersUrl(options, currentUrl),
+        libgnustepBaseUrl: resolveObjectiveCLibgnustepBaseUrl(options, currentUrl),
+        libgnustepBaseObjectUrl: resolveObjectiveCLibgnustepBaseObjectUrl(options, currentUrl),
+        foundationHeadersUrl: resolveObjectiveCFoundationHeadersUrl(options, currentUrl),
+        libffiUrl: resolveObjectiveCLibffiUrl(options, currentUrl),
+        integrity
+    };
+}
+export function resolveZigStdlibUrl(options, currentUrl = '') {
+    const configuredStdlibUrl = (typeof options === 'object' && options?.zig?.stdlibUrl) ||
+        (publicEnv.PUBLIC_WASM_ZIG_STDLIB_URL || '').trim();
+    if (configuredStdlibUrl) {
+        return resolveConfiguredUrl(configuredStdlibUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-zig/std.tar.gz`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-zig/std.tar.gz`, currentUrl);
+    }
+    return '';
+}
+export function resolveZigRuntimeAssetConfig(options, currentUrl = '') {
+    const configuredIntegrity = typeof options === 'object' ? options?.zig?.integrity : undefined;
+    return {
+        compilerUrl: resolveZigCompilerUrl(options, currentUrl),
+        stdlibUrl: resolveZigStdlibUrl(options, currentUrl),
+        integrity: snapshotZigExecutionAssetReceipts(configuredIntegrity === undefined ? WASM_ZIG_ASSET_RECEIPTS : configuredIntegrity)
+    };
+}
+export function resolveLispModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.lisp?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_LISP_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-lisp/index.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-lisp/index.js`, currentUrl);
+    }
+    return '';
+}
+function deriveLispManifestUrl(moduleUrl, currentUrl) {
+    if (!moduleUrl)
+        return '';
+    try {
+        const module = new URL(moduleUrl, currentUrl || undefined);
+        const manifest = new URL('runtime-manifest.v2.json', module);
+        manifest.search = module.search;
+        return manifest.href;
+    }
+    catch {
+        const queryIndex = moduleUrl.indexOf('?');
+        const query = queryIndex >= 0 ? moduleUrl.slice(queryIndex) : '';
+        const path = queryIndex >= 0 ? moduleUrl.slice(0, queryIndex) : moduleUrl;
+        return `${path.replace(/[^/]*$/u, '')}runtime-manifest.v2.json${query}`;
+    }
+}
+export function resolveLispRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.lisp : undefined;
+    const configuredModuleUrl = configured?.moduleUrl;
+    const publicModuleUrl = (publicEnv.PUBLIC_WASM_LISP_MODULE_URL || '').trim();
+    const rootUrl = typeof options === 'string' ? options : options?.rootUrl;
+    const moduleUrl = configuredModuleUrl
+        ? resolveConfiguredUrl(configuredModuleUrl, currentUrl)
+        : publicModuleUrl
+            ? resolveConfiguredUrl(publicModuleUrl, currentUrl)
+            : rootUrl !== undefined
+                ? resolveConfiguredUrl(`${normalizeRootUrl(rootUrl) || ''}/wasm-lisp/index.js`, currentUrl)
+                : '';
+    const configuredManifestUrl = configured?.manifestUrl || (publicEnv.PUBLIC_WASM_LISP_MANIFEST_URL || '').trim();
+    const configuredFingerprint = configured?.manifestFingerprint?.trim() ||
+        (publicEnv.PUBLIC_WASM_LISP_MANIFEST_FINGERPRINT || '').trim();
+    const usesBundledRoot = !configuredModuleUrl && !publicModuleUrl && rootUrl !== undefined;
+    return {
+        moduleUrl,
+        manifestUrl: configuredManifestUrl
+            ? resolveConfiguredUrl(configuredManifestUrl, currentUrl)
+            : deriveLispManifestUrl(moduleUrl, currentUrl),
+        manifestFingerprint: configuredFingerprint || (usesBundledRoot ? WASM_LISP_ASSET_VERSION : '')
+    };
+}
+const RUBY_RUNTIME_CONFIG_KEYS = [
+    'baseUrl',
+    'manifestUrl',
+    'moduleUrl',
+    'wasmUrl',
+    'profileId',
+    'artifactRevision',
+    'rubyVersion',
+    'rubyRevision',
+    'rubyWasmVersion',
+    'rubyWasmRevision',
+    'wasiSdkVersion',
+    'manifestFingerprint',
+    'manifestReceipt',
+    'moduleJavaScriptReceipt',
+    'wasmReceipt'
+];
+function snapshotRubyRuntimeAssetConfig(options) {
+    const source = typeof options === 'object' ? options?.ruby : undefined;
+    if (!source)
+        return undefined;
+    const snapshot = {};
+    for (const key of RUBY_RUNTIME_CONFIG_KEYS)
+        snapshot[key] = source[key];
+    return Object.freeze(snapshot);
+}
+function resolveRubyBaseUrlFromSnapshot(options, configured, currentUrl = '') {
+    const configuredBaseUrl = configured?.baseUrl;
+    if (configuredBaseUrl)
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-ruby/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-ruby/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-ruby/', currentUrl);
+}
+export function resolveRubyBaseUrl(options, currentUrl = '') {
+    return resolveRubyBaseUrlFromSnapshot(options, snapshotRubyRuntimeAssetConfig(options), currentUrl);
+}
+export function resolveRubyRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = snapshotRubyRuntimeAssetConfig(options);
+    const publicModuleUrl = (publicEnv.PUBLIC_WASM_RUBY_MODULE_URL || '').trim();
+    const publicWasmUrl = (publicEnv.PUBLIC_WASM_RUBY_WASM_URL || '').trim();
+    const usesCustomTrustBoundary = Boolean((configured && RUBY_RUNTIME_CONFIG_KEYS.some((key) => configured[key] !== undefined)) ||
+        publicModuleUrl ||
+        publicWasmUrl);
+    let preflightProfile;
+    try {
+        preflightProfile = snapshotRubyRuntimePreflightProfile(usesCustomTrustBoundary
+            ? {
+                profileId: configured?.profileId?.trim(),
+                artifactRevision: configured?.artifactRevision?.trim(),
+                rubyVersion: configured?.rubyVersion?.trim(),
+                rubyRevision: configured?.rubyRevision?.trim(),
+                rubyWasmVersion: configured?.rubyWasmVersion?.trim(),
+                rubyWasmRevision: configured?.rubyWasmRevision?.trim(),
+                wasiSdkVersion: configured?.wasiSdkVersion?.trim(),
+                manifestFingerprint: configured?.manifestFingerprint?.trim(),
+                manifestReceipt: configured?.manifestReceipt,
+                moduleJavaScriptReceipt: configured?.moduleJavaScriptReceipt,
+                wasmReceipt: configured?.wasmReceipt
+            }
+            : RUBY_RUNTIME_BUNDLE.profile);
+    }
+    catch (cause) {
+        throw new RuntimeConfigurationError('Ruby runtime custom assets require one complete profile and receipt bundle.', { cause, runtimeId: 'RUBY' });
+    }
+    const baseUrl = resolveRubyBaseUrlFromSnapshot(options, configured, currentUrl);
+    const resolvePinnedUrl = (configuredUrl, path, pin) => {
+        const sentinelOrigin = 'https://wasm-idle.invalid';
+        const candidate = resolveConfiguredUrl(configuredUrl || `${baseUrl}${path}`, currentUrl);
+        let url;
+        let expected;
+        try {
+            url = new URL(candidate, currentUrl || sentinelOrigin);
+            expected = new URL(`${baseUrl}${path}`, currentUrl || sentinelOrigin);
+        }
+        catch (cause) {
+            throw new RuntimeConfigurationError(`Ruby runtime ${path} URL is invalid.`, {
+                cause,
+                runtimeId: 'RUBY'
+            });
+        }
+        if ((url.protocol !== 'http:' && url.protocol !== 'https:') ||
+            url.username ||
+            url.password ||
+            url.hash ||
+            url.origin !== expected.origin ||
+            url.pathname !== expected.pathname ||
+            (url.search && url.search !== `?v=${pin}`)) {
+            throw new RuntimeConfigurationError(`Ruby runtime ${path} URL must use its canonical query-pinned path.`, { runtimeId: 'RUBY' });
+        }
+        if (!url.search)
+            url.searchParams.set('v', pin);
+        return currentUrl || candidate.startsWith('http://') || candidate.startsWith('https://')
+            ? url.href
+            : `${url.pathname}${url.search}`;
+    };
+    const manifestUrl = resolvePinnedUrl(configured?.manifestUrl, RUBY_RUNTIME_MANIFEST_PATH, preflightProfile.manifestFingerprint);
+    const moduleUrl = resolvePinnedUrl(configured?.moduleUrl || publicModuleUrl, RUBY_RUNTIME_MODULE_STORAGE_PATH, preflightProfile.moduleJavaScriptReceipt.sha256);
+    const wasmUrl = resolvePinnedUrl(configured?.wasmUrl || publicWasmUrl, RUBY_RUNTIME_WASM_STORAGE_PATH, preflightProfile.wasmReceipt.sha256);
+    return {
+        baseUrl,
+        manifestUrl,
+        moduleUrl,
+        wasmUrl,
+        preflightKey: JSON.stringify({
+            baseUrl,
+            manifestUrl,
+            moduleUrl,
+            wasmUrl,
+            profile: preflightProfile
+        }),
+        preflightProfile
+    };
+}
+export function resolveRubyWasmUrl(options, currentUrl = '') {
+    return resolveRubyRuntimeAssetConfig(options, currentUrl).wasmUrl;
+}
+export function resolveRBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.r?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_R_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/webr/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/webr/`, currentUrl);
+    }
+    return '';
+}
+export function resolveOctaveBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.octave?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_OCTAVE_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-octave/runtime/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-octave/runtime/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-octave/runtime/', currentUrl);
+}
+export function resolveOctaveWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.octave?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_OCTAVE_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-octave/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-octave/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-octave/runner-worker.js', currentUrl);
+}
+export function resolveOctaveManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.octave?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_OCTAVE_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-octave/runtime/runtime-manifest.v1.json`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-octave/runtime/runtime-manifest.v1.json`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-octave/runtime/runtime-manifest.v1.json', currentUrl);
+}
+export function resolveOctaveRuntimeAssetConfig(options, currentUrl = '') {
+    return {
+        baseUrl: resolveOctaveBaseUrl(options, currentUrl),
+        workerUrl: resolveOctaveWorkerUrl(options, currentUrl),
+        manifestUrl: resolveOctaveManifestUrl(options, currentUrl)
+    };
+}
+export function resolvePrologBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.prolog?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_PROLOG_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-prolog/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-prolog/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-prolog/', currentUrl);
+}
+export function resolvePrologWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.prolog?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_PROLOG_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-prolog/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-prolog/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-prolog/runner-worker.js', currentUrl);
+}
+export function resolvePrologManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = typeof options === 'object' ? options?.prolog?.manifestUrl : undefined;
+    if (configuredManifestUrl)
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    return `${resolvePrologBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolvePrologRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.prolog : undefined;
+    const manifestFingerprint = configured?.manifestFingerprint?.trim() || WASM_PROLOG_ASSET_VERSION;
+    const usesBundledProfile = manifestFingerprint === WASM_PROLOG_ASSET_VERSION;
+    const receipt = (configuredReceipt, bundledReceipt) => {
+        const selected = configuredReceipt || (usesBundledProfile ? bundledReceipt : undefined);
+        return selected
+            ? Object.freeze({
+                bytes: selected.bytes,
+                sha256: selected.sha256,
+                ...(selected.uncompressedBytes === undefined
+                    ? {}
+                    : { uncompressedBytes: selected.uncompressedBytes }),
+                ...(selected.uncompressedSha256 === undefined
+                    ? {}
+                    : { uncompressedSha256: selected.uncompressedSha256 })
+            })
+            : undefined;
+    };
+    const preflightProfile = snapshotPrologRuntimePreflightProfile({
+        profileId: configured?.profileId?.trim() ||
+            (usesBundledProfile ? WASM_PROLOG_RUNTIME_PROFILE.profileId : ''),
+        packageRevision: configured?.packageRevision?.trim() ||
+            (usesBundledProfile ? WASM_PROLOG_RUNTIME_PROFILE.packageRevision : ''),
+        swiplRevision: configured?.swiplRevision?.trim() ||
+            (usesBundledProfile ? WASM_PROLOG_RUNTIME_PROFILE.swiplRevision : ''),
+        manifestFingerprint,
+        manifestReceipt: receipt(configured?.manifestReceipt, WASM_PROLOG_RUNTIME_PROFILE.manifestReceipt),
+        javascriptReceipt: receipt(configured?.javascriptReceipt, WASM_PROLOG_RUNTIME_PROFILE.javascriptReceipt),
+        wasmReceipt: receipt(configured?.wasmReceipt, WASM_PROLOG_RUNTIME_PROFILE.wasmReceipt),
+        dataReceipt: receipt(configured?.dataReceipt, WASM_PROLOG_RUNTIME_PROFILE.dataReceipt)
+    });
+    return {
+        baseUrl: resolvePrologBaseUrl(options, currentUrl),
+        workerUrl: resolvePrologWorkerUrl(options, currentUrl),
+        manifestUrl: resolvePrologManifestUrl(options, currentUrl),
+        manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt: configured?.workerReceipt || WASM_PROLOG_RUNNER_RECEIPT
+    };
+}
+export function resolveGleamBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.gleam?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_GLEAM_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-gleam/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-gleam/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-gleam/', currentUrl);
+}
+export function resolveGleamWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.gleam?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_GLEAM_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-gleam/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-gleam/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-gleam/runner-worker.js', currentUrl);
+}
+export function resolveGleamManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.gleam?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_GLEAM_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-gleam/source-manifest.v2.json`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-gleam/source-manifest.v2.json`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-gleam/source-manifest.v2.json', currentUrl);
+}
+export function resolveGleamRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.gleam : undefined;
+    const envManifestFingerprint = (publicEnv.PUBLIC_WASM_GLEAM_MANIFEST_FINGERPRINT || '').trim();
+    const envWorkerSha256 = (publicEnv.PUBLIC_WASM_GLEAM_WORKER_SHA256 || '').trim();
+    const envWorkerBytesSource = (publicEnv.PUBLIC_WASM_GLEAM_WORKER_BYTES || '').trim();
+    const envWorkerBytes = /^\d+$/u.test(envWorkerBytesSource)
+        ? Number(envWorkerBytesSource)
+        : Number.NaN;
+    const envWorkerReceipt = /^[a-f0-9]{64}$/u.test(envWorkerSha256) &&
+        Number.isSafeInteger(envWorkerBytes) &&
+        envWorkerBytes > 0
+        ? { bytes: envWorkerBytes, sha256: envWorkerSha256 }
+        : undefined;
+    const usesCustomUrls = Boolean(configured?.baseUrl ||
+        configured?.workerUrl ||
+        configured?.manifestUrl ||
+        (publicEnv.PUBLIC_WASM_GLEAM_BASE_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_GLEAM_WORKER_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_GLEAM_MANIFEST_URL || '').trim());
+    return {
+        baseUrl: resolveGleamBaseUrl(options, currentUrl),
+        workerUrl: resolveGleamWorkerUrl(options, currentUrl),
+        manifestUrl: resolveGleamManifestUrl(options, currentUrl),
+        manifestFingerprint: configured?.manifestFingerprint?.trim() ||
+            envManifestFingerprint ||
+            (!usesCustomUrls ? WASM_GLEAM_ASSET_VERSION : undefined),
+        workerReceipt: configured?.workerReceipt ||
+            envWorkerReceipt ||
+            (!usesCustomUrls ? WASM_GLEAM_RUNNER_RECEIPT : undefined)
+    };
+}
+export function resolvePerlBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.perl?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_PERL_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-perl/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-perl/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-perl/', currentUrl);
+}
+export function resolvePerlWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.perl?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_PERL_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-perl/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-perl/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-perl/runner-worker.js', currentUrl);
+}
+export function resolvePerlManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.perl?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_PERL_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl)
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    return `${resolvePerlBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolvePerlRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.perl : undefined;
+    const usesCustomUrls = Boolean(configured?.baseUrl ||
+        configured?.workerUrl ||
+        configured?.manifestUrl ||
+        (publicEnv.PUBLIC_WASM_PERL_BASE_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_PERL_WORKER_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_PERL_MANIFEST_URL || '').trim());
+    const hasConfiguredTrust = !!configured &&
+        [
+            configured.manifestFingerprint,
+            configured.profileId,
+            configured.artifactRevision,
+            configured.webperlRevision,
+            configured.perlRevision,
+            configured.emscriptenRevision,
+            configured.manifestReceipt,
+            configured.javascriptReceipt,
+            configured.wasmReceipt,
+            configured.dataReceipt,
+            configured.workerReceipt
+        ].some((value) => value !== undefined);
+    const usesCustomTrustBoundary = usesCustomUrls || hasConfiguredTrust;
+    const selectedProfile = usesCustomTrustBoundary
+        ? {
+            profileId: configured?.profileId?.trim(),
+            artifactRevision: configured?.artifactRevision?.trim(),
+            webperlRevision: configured?.webperlRevision?.trim(),
+            perlRevision: configured?.perlRevision?.trim(),
+            emscriptenRevision: configured?.emscriptenRevision?.trim(),
+            manifestFingerprint: configured?.manifestFingerprint?.trim(),
+            manifestReceipt: configured?.manifestReceipt,
+            javascriptReceipt: configured?.javascriptReceipt,
+            wasmReceipt: configured?.wasmReceipt,
+            dataReceipt: configured?.dataReceipt
+        }
+        : WASM_PERL_RUNTIME_BUNDLE.profile;
+    const preflightProfile = snapshotPerlRuntimePreflightProfile(selectedProfile);
+    const workerReceipt = usesCustomTrustBoundary
+        ? configured?.workerReceipt
+        : WASM_PERL_RUNTIME_BUNDLE.workerReceipt;
+    if (!workerReceipt) {
+        throw new RuntimeConfigurationError('WebPerl runtime requires one complete profile and runner receipt bundle.', { runtimeId: 'PERL' });
+    }
+    return {
+        baseUrl: resolvePerlBaseUrl(options, currentUrl),
+        workerUrl: resolvePerlWorkerUrl(options, currentUrl),
+        manifestUrl: resolvePerlManifestUrl(options, currentUrl),
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt
+    };
+}
+export function resolveTclBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.tcl?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_TCL_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-tcl/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-tcl/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-tcl/', currentUrl);
+}
+export function resolveTclWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.tcl?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_TCL_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-tcl/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-tcl/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-tcl/runner-worker.js', currentUrl);
+}
+export function resolveTclManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = typeof options === 'object' ? options?.tcl?.manifestUrl : undefined;
+    if (configuredManifestUrl)
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    return `${resolveTclBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveTclRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.tcl : undefined;
+    const hasConfiguredTrust = !!configured &&
+        [
+            configured.manifestFingerprint,
+            configured.profileId,
+            configured.artifactRevision,
+            configured.waclRevision,
+            configured.tclRevision,
+            configured.requireJsRevision,
+            configured.emscriptenRevision,
+            configured.manifestReceipt,
+            configured.requireJsReceipt,
+            configured.customDataReceipt,
+            configured.libraryDataReceipt,
+            configured.glueReceipt,
+            configured.wasmReceipt,
+            configured.workerReceipt
+        ].some((value) => value !== undefined);
+    const selectedProfile = hasConfiguredTrust
+        ? {
+            profileId: configured?.profileId?.trim(),
+            artifactRevision: configured?.artifactRevision?.trim(),
+            waclRevision: configured?.waclRevision?.trim(),
+            tclRevision: configured?.tclRevision?.trim(),
+            requireJsRevision: configured?.requireJsRevision?.trim(),
+            emscriptenRevision: configured?.emscriptenRevision?.trim(),
+            manifestFingerprint: configured?.manifestFingerprint?.trim(),
+            manifestReceipt: configured?.manifestReceipt,
+            requireJsReceipt: configured?.requireJsReceipt,
+            customDataReceipt: configured?.customDataReceipt,
+            libraryDataReceipt: configured?.libraryDataReceipt,
+            glueReceipt: configured?.glueReceipt,
+            wasmReceipt: configured?.wasmReceipt
+        }
+        : WASM_TCL_RUNTIME_BUNDLE.profile;
+    const preflightProfile = snapshotTclRuntimePreflightProfile(selectedProfile);
+    const workerReceipt = hasConfiguredTrust
+        ? configured?.workerReceipt
+        : WASM_TCL_RUNTIME_BUNDLE.workerReceipt;
+    if (!workerReceipt) {
+        throw new RuntimeConfigurationError('Tcl runtime requires one complete profile and runner receipt bundle.', { runtimeId: 'TCL' });
+    }
+    return {
+        baseUrl: resolveTclBaseUrl(options, currentUrl),
+        workerUrl: resolveTclWorkerUrl(options, currentUrl),
+        manifestUrl: resolveTclManifestUrl(options, currentUrl),
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt
+    };
+}
+export function resolveAwkBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.awk?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_AWK_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-awk/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-awk/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-awk/', currentUrl);
+}
+export function resolveAwkWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.awk?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_AWK_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-awk/runner-worker.v2.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-awk/runner-worker.v2.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-awk/runner-worker.v2.js', currentUrl);
+}
+function resolveAwkPinnedAssetUrl(configuredUrl, currentUrl, expectedFileName, pin) {
+    const sentinelOrigin = 'https://wasm-idle.invalid';
+    let url;
+    try {
+        url = new URL(configuredUrl, currentUrl || sentinelOrigin);
+    }
+    catch (cause) {
+        throw new RuntimeConfigurationError(`AWK runtime ${expectedFileName} URL is invalid.`, {
+            cause,
+            runtimeId: 'AWK'
+        });
+    }
+    if ((url.protocol !== 'http:' && url.protocol !== 'https:') ||
+        url.username ||
+        url.password ||
+        url.hash ||
+        !url.pathname.endsWith(`/${expectedFileName}`) ||
+        (url.search && url.search !== `?v=${pin}`)) {
+        throw new RuntimeConfigurationError(`AWK runtime ${expectedFileName} URL must use its query-pinned immutable path.`, { runtimeId: 'AWK' });
+    }
+    if (!url.search)
+        url.searchParams.set('v', pin);
+    return currentUrl || configuredUrl.startsWith('http://') || configuredUrl.startsWith('https://')
+        ? url.href
+        : `${url.pathname}${url.search}`;
+}
+export function resolveAwkRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.awk : undefined;
+    const hasConfiguredTrust = !!configured &&
+        [
+            configured.profileId,
+            configured.goVersion,
+            configured.goawkVersion,
+            configured.manifestFingerprint,
+            configured.manifestReceipt,
+            configured.workerReceipt,
+            configured.goShimReceipt,
+            configured.wasmReceipt
+        ].some((value) => value !== undefined);
+    const bundledProfile = snapshotAwkRuntimePreflightProfile(WASM_AWK_RUNTIME_BUNDLE.profile);
+    let preflightProfile = bundledProfile;
+    if (hasConfiguredTrust) {
+        let configuredProfile;
+        try {
+            configuredProfile = snapshotAwkRuntimePreflightProfile({
+                profileId: configured?.profileId?.trim(),
+                goVersion: configured?.goVersion?.trim(),
+                goawkVersion: configured?.goawkVersion?.trim(),
+                manifestFingerprint: configured?.manifestFingerprint?.trim(),
+                manifestReceipt: configured?.manifestReceipt,
+                workerReceipt: configured?.workerReceipt,
+                goShimReceipt: configured?.goShimReceipt,
+                wasmReceipt: configured?.wasmReceipt
+            });
+        }
+        catch (cause) {
+            throw new RuntimeConfigurationError('AWK runtime custom assets require one complete profile and receipt bundle.', { cause, runtimeId: 'AWK' });
+        }
+        if (JSON.stringify(configuredProfile) !== JSON.stringify(bundledProfile)) {
+            throw new RuntimeConfigurationError('AWK runtime public configuration accepts URL mirrors only; receipts must match the bundled profile.', { runtimeId: 'AWK' });
+        }
+        preflightProfile = configuredProfile;
+    }
+    const baseUrl = resolveAwkBaseUrl(options, currentUrl);
+    const workerUrl = resolveAwkPinnedAssetUrl(configured?.workerUrl ||
+        (publicEnv.PUBLIC_WASM_AWK_WORKER_URL || '').trim() ||
+        `${baseUrl}runner-worker.v2.js`, currentUrl, 'runner-worker.v2.js', preflightProfile.workerReceipt.sha256);
+    const manifestUrl = resolveAwkPinnedAssetUrl(configured?.manifestUrl || `${baseUrl}runtime-manifest.v2.json`, currentUrl, 'runtime-manifest.v2.json', preflightProfile.manifestFingerprint);
+    const identity = { baseUrl, workerUrl, manifestUrl, profile: preflightProfile };
+    return {
+        baseUrl,
+        workerUrl,
+        manifestUrl,
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(identity),
+        preflightProfile,
+        workerReceipt: preflightProfile.workerReceipt
+    };
+}
+export function resolvePascalBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.pascal?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_PASCAL_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-pascal/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-pascal/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-pascal/', currentUrl);
+}
+export function resolvePascalWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.pascal?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_PASCAL_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-pascal/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-pascal/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-pascal/runner-worker.js', currentUrl);
+}
+export function resolvePascalRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.pascal : undefined;
+    const usesCustomTrustBoundary = Boolean((configured && Object.values(configured).some((value) => value !== undefined)) ||
+        (publicEnv.PUBLIC_WASM_PASCAL_BASE_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_PASCAL_WORKER_URL || '').trim());
+    let preflightProfile;
+    try {
+        preflightProfile = snapshotPascalRuntimePreflightProfile(usesCustomTrustBoundary
+            ? {
+                profileId: configured?.profileId?.trim(),
+                artifactRevision: configured?.artifactRevision?.trim(),
+                pas2jsVersion: configured?.pas2jsVersion?.trim(),
+                pas2jsRevision: configured?.pas2jsRevision?.trim(),
+                manifestFingerprint: configured?.manifestFingerprint?.trim(),
+                manifestReceipt: configured?.manifestReceipt,
+                compilerJavaScriptReceipt: configured?.compilerJavaScriptReceipt,
+                rtlJavaScriptReceipt: configured?.rtlJavaScriptReceipt,
+                systemPascalReceipt: configured?.systemPascalReceipt
+            }
+            : WASM_PASCAL_RUNTIME_BUNDLE.profile);
+    }
+    catch (cause) {
+        throw new RuntimeConfigurationError('Pascal runtime custom assets require one complete profile and receipt bundle.', { cause, runtimeId: 'PASCAL' });
+    }
+    const workerReceipt = usesCustomTrustBoundary
+        ? configured?.workerReceipt
+        : WASM_PASCAL_RUNTIME_BUNDLE.workerReceipt;
+    if (!workerReceipt ||
+        Object.keys(workerReceipt).sort().join(',') !== 'bytes,sha256' ||
+        !Number.isSafeInteger(workerReceipt.bytes) ||
+        workerReceipt.bytes <= 0 ||
+        typeof workerReceipt.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(workerReceipt.sha256)) {
+        throw new RuntimeConfigurationError('Pascal runtime custom assets require one complete profile and runner receipt bundle.', { runtimeId: 'PASCAL' });
+    }
+    const baseUrl = resolvePascalBaseUrl(options, currentUrl);
+    const resolvePinnedUrl = (configuredUrl, path, pin) => {
+        const sentinelOrigin = 'https://wasm-idle.invalid';
+        const candidate = resolveConfiguredUrl(configuredUrl || `${baseUrl}${path}`, currentUrl);
+        let url;
+        let expected;
+        try {
+            url = new URL(candidate, currentUrl || sentinelOrigin);
+            expected = new URL(`${baseUrl}${path}`, currentUrl || sentinelOrigin);
+        }
+        catch (cause) {
+            throw new RuntimeConfigurationError(`Pascal runtime ${path} URL is invalid.`, {
+                cause,
+                runtimeId: 'PASCAL'
+            });
+        }
+        if ((url.protocol !== 'http:' && url.protocol !== 'https:') ||
+            url.username ||
+            url.password ||
+            url.hash ||
+            url.origin !== expected.origin ||
+            url.pathname !== expected.pathname ||
+            (url.search && url.search !== `?v=${pin}`)) {
+            throw new RuntimeConfigurationError(`Pascal runtime ${path} URL must use its canonical query-pinned path.`, { runtimeId: 'PASCAL' });
+        }
+        if (!url.search)
+            url.searchParams.set('v', pin);
+        return currentUrl || candidate.startsWith('http://') || candidate.startsWith('https://')
+            ? url.href
+            : `${url.pathname}${url.search}`;
+    };
+    const workerUrl = resolvePinnedUrl(configured?.workerUrl ||
+        (publicEnv.PUBLIC_WASM_PASCAL_WORKER_URL || '').trim() ||
+        resolvePascalWorkerUrl(options, currentUrl), 'runner-worker.js', workerReceipt.sha256);
+    const manifestUrl = resolvePinnedUrl(configured?.manifestUrl, 'runtime-manifest.v2.json', preflightProfile.manifestFingerprint);
+    const compilerJavaScriptUrl = resolvePinnedUrl(configured?.compilerJavaScriptUrl, 'compiler.js.gz.bin', preflightProfile.compilerJavaScriptReceipt.sha256);
+    const rtlJavaScriptUrl = resolvePinnedUrl(configured?.rtlJavaScriptUrl, 'rtl.js.bin', preflightProfile.rtlJavaScriptReceipt.sha256);
+    const systemPascalUrl = resolvePinnedUrl(configured?.systemPascalUrl, 'system.pas.bin', preflightProfile.systemPascalReceipt.sha256);
+    const identity = {
+        baseUrl,
+        workerUrl,
+        manifestUrl,
+        compilerJavaScriptUrl,
+        rtlJavaScriptUrl,
+        systemPascalUrl,
+        profile: preflightProfile,
+        workerReceipt
+    };
+    return {
+        baseUrl,
+        workerUrl,
+        manifestUrl,
+        compilerJavaScriptUrl,
+        rtlJavaScriptUrl,
+        systemPascalUrl,
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(identity),
+        preflightProfile,
+        workerReceipt
+    };
+}
+export function resolveClojureScriptBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.clojurescript?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_CLOJURESCRIPT_BASE_URL || '').trim();
+    if (configuredBaseUrl)
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-clojurescript/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-clojurescript/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-clojurescript/', currentUrl);
+}
+export function resolveClojureScriptWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.clojurescript?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_CLOJURESCRIPT_WORKER_URL || '').trim();
+    if (configuredWorkerUrl)
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-clojurescript/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-clojurescript/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-clojurescript/runner-worker.js', currentUrl);
+}
+export function resolveClojureScriptManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = typeof options === 'object' ? options?.clojurescript?.manifestUrl : undefined;
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    return `${resolveClojureScriptBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveClojureScriptRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.clojurescript : undefined;
+    const manifestFingerprint = configured?.manifestFingerprint?.trim() || WASM_CLOJURESCRIPT_ASSET_VERSION;
+    const usesBundledProfile = manifestFingerprint === WASM_CLOJURESCRIPT_ASSET_VERSION;
+    const receipt = (configuredReceipt, bundledReceipt) => {
+        const selected = configuredReceipt || (usesBundledProfile ? bundledReceipt : undefined);
+        return selected
+            ? Object.freeze({
+                bytes: selected.bytes,
+                sha256: selected.sha256,
+                ...(selected.uncompressedBytes === undefined
+                    ? {}
+                    : { uncompressedBytes: selected.uncompressedBytes }),
+                ...(selected.uncompressedSha256 === undefined
+                    ? {}
+                    : { uncompressedSha256: selected.uncompressedSha256 })
+            })
+            : undefined;
+    };
+    const preflightProfile = Object.freeze({
+        profileId: configured?.profileId?.trim() ||
+            (usesBundledProfile ? WASM_CLOJURESCRIPT_RUNTIME_PROFILE.profileId : ''),
+        sourceRevision: configured?.sourceRevision?.trim() ||
+            (usesBundledProfile ? WASM_CLOJURESCRIPT_RUNTIME_PROFILE.sourceRevision : ''),
+        integrationRevision: configured?.integrationRevision?.trim() ||
+            (usesBundledProfile ? WASM_CLOJURESCRIPT_RUNTIME_PROFILE.integrationRevision : ''),
+        manifestFingerprint,
+        manifestReceipt: receipt(configured?.manifestReceipt, WASM_CLOJURESCRIPT_RUNTIME_PROFILE.manifestReceipt),
+        compilerReceipt: receipt(configured?.compilerReceipt, WASM_CLOJURESCRIPT_RUNTIME_PROFILE.compilerReceipt)
+    });
+    return {
+        baseUrl: resolveClojureScriptBaseUrl(options, currentUrl),
+        workerUrl: resolveClojureScriptWorkerUrl(options, currentUrl),
+        manifestUrl: resolveClojureScriptManifestUrl(options, currentUrl),
+        manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt: configured?.workerReceipt || WASM_CLOJURESCRIPT_RUNNER_RECEIPT
+    };
+}
+export function resolveForthBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.forth?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_FORTH_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-forth/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-forth/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-forth/', currentUrl);
+}
+export function resolveForthWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.forth?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_FORTH_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    return `${resolveForthBaseUrl(options, currentUrl)}runner-worker.js`;
+}
+export function resolveForthManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = typeof options === 'object' ? options?.forth?.manifestUrl : undefined;
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    return `${resolveForthBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveForthRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.forth : undefined;
+    const manifestFingerprint = configured?.manifestFingerprint?.trim() || WASM_FORTH_ASSET_VERSION;
+    const usesBundledProfile = manifestFingerprint === WASM_FORTH_ASSET_VERSION;
+    const manifestReceipt = configured?.manifestReceipt ||
+        (usesBundledProfile ? WASM_FORTH_RUNTIME_PROFILE.manifestReceipt : undefined);
+    const runtimeReceipt = configured?.runtimeReceipt ||
+        (usesBundledProfile ? WASM_FORTH_RUNTIME_PROFILE.runtimeReceipt : undefined);
+    const preflightProfile = Object.freeze({
+        profileId: configured?.profileId?.trim() ||
+            (usesBundledProfile ? WASM_FORTH_RUNTIME_PROFILE.profileId : ''),
+        implementationVersion: configured?.implementationVersion?.trim() ||
+            (usesBundledProfile ? WASM_FORTH_RUNTIME_PROFILE.implementationVersion : ''),
+        manifestFingerprint,
+        manifestReceipt: manifestReceipt
+            ? Object.freeze({ bytes: manifestReceipt.bytes, sha256: manifestReceipt.sha256 })
+            : undefined,
+        runtimeReceipt: runtimeReceipt
+            ? Object.freeze({ bytes: runtimeReceipt.bytes, sha256: runtimeReceipt.sha256 })
+            : undefined
+    });
+    return {
+        baseUrl: resolveForthBaseUrl(options, currentUrl),
+        workerUrl: resolveForthWorkerUrl(options, currentUrl),
+        manifestUrl: resolveForthManifestUrl(options, currentUrl),
+        manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt: configured?.workerReceipt || WASM_FORTH_RUNNER_RECEIPT
+    };
+}
+export function resolveJBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.j?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_J_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-j/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-j/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-j/', currentUrl);
+}
+export function resolveJWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.j?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_J_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-j/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-j/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-j/runner-worker.js', currentUrl);
+}
+export function resolveJManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = typeof options === 'object' ? options?.j?.manifestUrl : undefined;
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    return `${resolveJBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveJRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.j : undefined;
+    const manifestFingerprint = configured?.manifestFingerprint?.trim() || WASM_J_ASSET_VERSION;
+    const usesBundledProfile = manifestFingerprint === WASM_J_ASSET_VERSION;
+    const receipt = (configuredReceipt, bundledReceipt) => {
+        const selected = configuredReceipt || (usesBundledProfile ? bundledReceipt : undefined);
+        return selected
+            ? Object.freeze({
+                bytes: selected.bytes,
+                sha256: selected.sha256,
+                ...(selected.uncompressedBytes === undefined
+                    ? {}
+                    : { uncompressedBytes: selected.uncompressedBytes }),
+                ...(selected.uncompressedSha256 === undefined
+                    ? {}
+                    : { uncompressedSha256: selected.uncompressedSha256 })
+            })
+            : undefined;
+    };
+    const preflightProfile = Object.freeze({
+        profileId: configured?.profileId?.trim() ||
+            (usesBundledProfile ? WASM_J_RUNTIME_PROFILE.profileId : ''),
+        sourceRevision: configured?.sourceRevision?.trim() ||
+            (usesBundledProfile ? WASM_J_RUNTIME_PROFILE.sourceRevision : ''),
+        manifestFingerprint,
+        manifestReceipt: receipt(configured?.manifestReceipt, WASM_J_RUNTIME_PROFILE.manifestReceipt),
+        moduleReceipt: receipt(configured?.moduleReceipt, WASM_J_RUNTIME_PROFILE.moduleReceipt),
+        wasmReceipt: receipt(configured?.wasmReceipt, WASM_J_RUNTIME_PROFILE.wasmReceipt)
+    });
+    return {
+        baseUrl: resolveJBaseUrl(options, currentUrl),
+        workerUrl: resolveJWorkerUrl(options, currentUrl),
+        manifestUrl: resolveJManifestUrl(options, currentUrl),
+        manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt: configured?.workerReceipt || WASM_J_RUNNER_RECEIPT
+    };
+}
+export function resolveBqnBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.bqn?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_BQN_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-bqn/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-bqn/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-bqn/', currentUrl);
+}
+export function resolveBqnWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.bqn?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_BQN_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-bqn/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-bqn/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-bqn/runner-worker.js', currentUrl);
+}
+export function resolveBqnManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = typeof options === 'object' ? options?.bqn?.manifestUrl : undefined;
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    return `${resolveBqnBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveBqnRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.bqn : undefined;
+    const manifestFingerprint = configured?.manifestFingerprint?.trim() || WASM_BQN_ASSET_VERSION;
+    const usesBundledProfile = manifestFingerprint === WASM_BQN_ASSET_VERSION;
+    const receipt = (configuredReceipt, bundledReceipt) => {
+        const selected = configuredReceipt || (usesBundledProfile ? bundledReceipt : undefined);
+        return selected
+            ? Object.freeze({
+                bytes: selected.bytes,
+                sha256: selected.sha256,
+                ...(selected.uncompressedBytes === undefined
+                    ? {}
+                    : { uncompressedBytes: selected.uncompressedBytes }),
+                ...(selected.uncompressedSha256 === undefined
+                    ? {}
+                    : { uncompressedSha256: selected.uncompressedSha256 })
+            })
+            : undefined;
+    };
+    const preflightProfile = Object.freeze({
+        profileId: configured?.profileId?.trim() ||
+            (usesBundledProfile ? WASM_BQN_RUNTIME_PROFILE.profileId : ''),
+        sourceRevision: configured?.sourceRevision?.trim() ||
+            (usesBundledProfile ? WASM_BQN_RUNTIME_PROFILE.sourceRevision : ''),
+        manifestFingerprint,
+        manifestReceipt: receipt(configured?.manifestReceipt, WASM_BQN_RUNTIME_PROFILE.manifestReceipt),
+        moduleReceipt: receipt(configured?.moduleReceipt, WASM_BQN_RUNTIME_PROFILE.moduleReceipt),
+        wasmReceipt: receipt(configured?.wasmReceipt, WASM_BQN_RUNTIME_PROFILE.wasmReceipt)
+    });
+    return {
+        baseUrl: resolveBqnBaseUrl(options, currentUrl),
+        workerUrl: resolveBqnWorkerUrl(options, currentUrl),
+        manifestUrl: resolveBqnManifestUrl(options, currentUrl),
+        manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt: configured?.workerReceipt || WASM_BQN_RUNNER_RECEIPT
+    };
+}
+export function resolveJanetBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.janet?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_JANET_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-janet/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-janet/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-janet/', currentUrl);
+}
+export function resolveJanetWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.janet?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_JANET_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-janet/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-janet/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-janet/runner-worker.js', currentUrl);
+}
+export function resolveJanetManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.janet?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_JANET_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl)
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    return `${resolveJanetBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveJanetRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.janet : undefined;
+    const envManifestFingerprint = (publicEnv.PUBLIC_WASM_JANET_MANIFEST_FINGERPRINT || '').trim();
+    const envWorkerSha256 = (publicEnv.PUBLIC_WASM_JANET_WORKER_SHA256 || '').trim();
+    const envWorkerBytesSource = (publicEnv.PUBLIC_WASM_JANET_WORKER_BYTES || '').trim();
+    const usesCustomUrls = Boolean(configured?.baseUrl ||
+        configured?.workerUrl ||
+        configured?.manifestUrl ||
+        (publicEnv.PUBLIC_WASM_JANET_BASE_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_JANET_WORKER_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_JANET_MANIFEST_URL || '').trim());
+    const hasConfiguredTrust = !!configured &&
+        [
+            configured.manifestFingerprint,
+            configured.profileId,
+            configured.artifactRevision,
+            configured.janetVersion,
+            configured.emscriptenVersion,
+            configured.manifestReceipt,
+            configured.javascriptReceipt,
+            configured.wasmReceipt,
+            configured.workerReceipt
+        ].some((value) => value !== undefined);
+    const usesCustomTrustBoundary = usesCustomUrls ||
+        hasConfiguredTrust ||
+        Boolean(envManifestFingerprint || envWorkerSha256 || envWorkerBytesSource);
+    const selectedProfile = usesCustomTrustBoundary
+        ? {
+            profileId: configured?.profileId?.trim(),
+            artifactRevision: configured?.artifactRevision?.trim(),
+            janetVersion: configured?.janetVersion?.trim(),
+            emscriptenVersion: configured?.emscriptenVersion?.trim(),
+            manifestFingerprint: configured?.manifestFingerprint?.trim(),
+            manifestReceipt: configured?.manifestReceipt,
+            javascriptReceipt: configured?.javascriptReceipt,
+            wasmReceipt: configured?.wasmReceipt
+        }
+        : WASM_JANET_RUNTIME_BUNDLE.profile;
+    const preflightProfile = snapshotJanetRuntimePreflightProfile(selectedProfile);
+    const workerReceipt = usesCustomTrustBoundary
+        ? configured?.workerReceipt
+        : WASM_JANET_RUNTIME_BUNDLE.workerReceipt;
+    if (!workerReceipt) {
+        throw new RuntimeConfigurationError('Janet runtime requires one complete profile and runner receipt bundle.', { runtimeId: 'JANET' });
+    }
+    return {
+        baseUrl: resolveJanetBaseUrl(options, currentUrl),
+        workerUrl: resolveJanetWorkerUrl(options, currentUrl),
+        manifestUrl: resolveJanetManifestUrl(options, currentUrl),
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt
+    };
+}
+export function resolveJuliaBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.julia?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_JULIA_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-julia/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-julia/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-julia/', currentUrl);
+}
+export function resolveJuliaWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.julia?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_JULIA_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-julia/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-julia/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-julia/runner-worker.js', currentUrl);
+}
+export function resolveJuliaRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.julia : undefined;
+    const envManifestFingerprint = (publicEnv.PUBLIC_WASM_JULIA_MANIFEST_FINGERPRINT || '').trim();
+    const envWorkerSha256 = (publicEnv.PUBLIC_WASM_JULIA_WORKER_SHA256 || '').trim();
+    const envWorkerBytesSource = (publicEnv.PUBLIC_WASM_JULIA_WORKER_BYTES || '').trim();
+    const usesCustomUrls = Boolean(configured?.baseUrl ||
+        configured?.workerUrl ||
+        configured?.manifestUrl ||
+        (publicEnv.PUBLIC_WASM_JULIA_BASE_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_JULIA_WORKER_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_JULIA_MANIFEST_URL || '').trim());
+    const hasConfiguredTrust = !!configured &&
+        [
+            configured.manifestFingerprint,
+            configured.profileId,
+            configured.packageRevision,
+            configured.importedByCommit,
+            configured.juliaVersion,
+            configured.emscriptenVersion,
+            configured.manifestReceipt,
+            configured.javascriptReceipt,
+            configured.wasmReceipt,
+            configured.dataReceipt,
+            configured.workerReceipt
+        ].some((value) => value !== undefined);
+    const usesCustomTrustBoundary = usesCustomUrls ||
+        hasConfiguredTrust ||
+        Boolean(envManifestFingerprint || envWorkerSha256 || envWorkerBytesSource);
+    const selectedProfile = usesCustomTrustBoundary
+        ? {
+            profileId: configured?.profileId?.trim(),
+            packageRevision: configured?.packageRevision?.trim(),
+            importedByCommit: configured?.importedByCommit?.trim(),
+            juliaVersion: configured?.juliaVersion?.trim(),
+            emscriptenVersion: configured?.emscriptenVersion?.trim(),
+            manifestFingerprint: configured?.manifestFingerprint?.trim(),
+            manifestReceipt: configured?.manifestReceipt,
+            javascriptReceipt: configured?.javascriptReceipt,
+            wasmReceipt: configured?.wasmReceipt,
+            dataReceipt: configured?.dataReceipt
+        }
+        : WASM_JULIA_RUNTIME_BUNDLE.profile;
+    const preflightProfile = snapshotJuliaRuntimePreflightProfile(selectedProfile);
+    const workerReceipt = usesCustomTrustBoundary
+        ? configured?.workerReceipt
+        : WASM_JULIA_RUNTIME_BUNDLE.workerReceipt;
+    if (!workerReceipt) {
+        throw new RuntimeConfigurationError('Julia runtime requires one complete profile and runner receipt bundle.', { runtimeId: 'JULIA' });
+    }
+    return {
+        baseUrl: resolveJuliaBaseUrl(options, currentUrl),
+        workerUrl: resolveJuliaWorkerUrl(options, currentUrl),
+        manifestUrl: resolveJuliaManifestUrl(options, currentUrl),
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt
+    };
+}
+export function resolveJuliaManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.julia?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_JULIA_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl)
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    return `${resolveJuliaBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveNimBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.nim?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_NIM_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-nim/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-nim/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-nim/', currentUrl);
+}
+export function resolveNimWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.nim?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_NIM_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-nim/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-nim/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-nim/runner-worker.js', currentUrl);
+}
+export function resolveNimRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.nim : undefined;
+    const envManifestFingerprint = (publicEnv.PUBLIC_WASM_NIM_MANIFEST_FINGERPRINT || '').trim();
+    const envWorkerSha256 = (publicEnv.PUBLIC_WASM_NIM_WORKER_SHA256 || '').trim();
+    const envWorkerBytesSource = (publicEnv.PUBLIC_WASM_NIM_WORKER_BYTES || '').trim();
+    const envWorkerBytes = /^\d+$/u.test(envWorkerBytesSource)
+        ? Number(envWorkerBytesSource)
+        : Number.NaN;
+    const envWorkerReceipt = /^[a-f0-9]{64}$/u.test(envWorkerSha256) &&
+        Number.isSafeInteger(envWorkerBytes) &&
+        envWorkerBytes > 0
+        ? { bytes: envWorkerBytes, sha256: envWorkerSha256 }
+        : undefined;
+    const usesCustomUrls = Boolean(configured?.baseUrl ||
+        configured?.workerUrl ||
+        configured?.manifestUrl ||
+        (publicEnv.PUBLIC_WASM_NIM_BASE_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_NIM_WORKER_URL || '').trim() ||
+        (publicEnv.PUBLIC_WASM_NIM_MANIFEST_URL || '').trim());
+    const hasConfiguredTrust = !!configured &&
+        [
+            configured.manifestFingerprint,
+            configured.profileId,
+            configured.artifactRevision,
+            configured.nimRevision,
+            configured.llvmRevision,
+            configured.memfsRevision,
+            configured.emscriptenRevision,
+            configured.manifestReceipt,
+            configured.nimJavaScriptReceipt,
+            configured.nimWasmReceipt,
+            configured.nimbaseReceipt,
+            configured.clangJavaScriptReceipt,
+            configured.clangWasmReceipt,
+            configured.lldWasmReceipt,
+            configured.memfsWasmReceipt,
+            configured.sysrootReceipt,
+            configured.workerReceipt
+        ].some((value) => value !== undefined);
+    const usesCustomTrustBoundary = usesCustomUrls ||
+        hasConfiguredTrust ||
+        Boolean(envManifestFingerprint || envWorkerSha256 || envWorkerBytesSource);
+    const selectedProfile = usesCustomTrustBoundary
+        ? {
+            profileId: configured?.profileId?.trim(),
+            artifactRevision: configured?.artifactRevision?.trim(),
+            nimRevision: configured?.nimRevision?.trim(),
+            llvmRevision: configured?.llvmRevision?.trim(),
+            memfsRevision: configured?.memfsRevision?.trim(),
+            emscriptenRevision: configured?.emscriptenRevision?.trim(),
+            manifestFingerprint: configured?.manifestFingerprint?.trim() || envManifestFingerprint,
+            manifestReceipt: configured?.manifestReceipt,
+            nimJavaScriptReceipt: configured?.nimJavaScriptReceipt,
+            nimWasmReceipt: configured?.nimWasmReceipt,
+            nimbaseReceipt: configured?.nimbaseReceipt,
+            clangJavaScriptReceipt: configured?.clangJavaScriptReceipt,
+            clangWasmReceipt: configured?.clangWasmReceipt,
+            lldWasmReceipt: configured?.lldWasmReceipt,
+            memfsWasmReceipt: configured?.memfsWasmReceipt,
+            sysrootReceipt: configured?.sysrootReceipt
+        }
+        : WASM_NIM_RUNTIME_BUNDLE.profile;
+    const preflightProfile = snapshotNimRuntimePreflightProfile(selectedProfile);
+    const workerReceipt = usesCustomTrustBoundary
+        ? configured?.workerReceipt || envWorkerReceipt
+        : WASM_NIM_RUNTIME_BUNDLE.workerReceipt;
+    if (!workerReceipt ||
+        !Number.isSafeInteger(workerReceipt.bytes) ||
+        workerReceipt.bytes <= 0 ||
+        !/^[a-f0-9]{64}$/u.test(workerReceipt.sha256)) {
+        throw new RuntimeConfigurationError('Nim runtime requires one complete profile and runner receipt bundle.', { runtimeId: 'NIM' });
+    }
+    const hasConfiguredManifestUrl = Boolean(configured?.manifestUrl || (publicEnv.PUBLIC_WASM_NIM_MANIFEST_URL || '').trim());
+    const baseUrl = resolveNimBaseUrl(options, currentUrl);
+    const resolvedManifestUrl = resolveNimManifestUrl(options, currentUrl);
+    const manifestUrl = hasConfiguredManifestUrl
+        ? resolvedManifestUrl
+        : `${resolvedManifestUrl}?v=${preflightProfile.manifestFingerprint}`;
+    try {
+        const comparisonBaseUrl = new URL(baseUrl, 'https://wasm-idle.invalid/');
+        const expectedManifestUrl = new URL('runtime-manifest.v2.json', comparisonBaseUrl);
+        expectedManifestUrl.search = `?v=${preflightProfile.manifestFingerprint}`;
+        if (new URL(manifestUrl, comparisonBaseUrl).href !== expectedManifestUrl.href) {
+            throw new Error('manifest URL mismatch');
+        }
+    }
+    catch (error) {
+        throw new RuntimeConfigurationError('Nim runtime manifest URL must be the canonical query-pinned v2 manifest.', { cause: error, runtimeId: 'NIM' });
+    }
+    return {
+        baseUrl,
+        workerUrl: resolveNimWorkerUrl(options, currentUrl),
+        manifestUrl,
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(preflightProfile),
+        preflightProfile,
+        workerReceipt
+    };
+}
+export function resolveNimManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.nim?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_NIM_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl)
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    return `${resolveNimBaseUrl(options, currentUrl)}runtime-manifest.v2.json`;
+}
+export function resolveBashBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = typeof options === 'object' ? options?.bash?.baseUrl : undefined;
+    if (configuredBaseUrl)
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-bash/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-bash/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-bash/', currentUrl);
+}
+export function resolveBashRuntimeAssetConfig(options, currentUrl = '') {
+    const configured = typeof options === 'object' ? options?.bash : undefined;
+    if (configured?.workerUrl !== undefined) {
+        throw new RuntimeConfigurationError('Bash runtime workerUrl overrides are no longer supported; use the fixed verified bootstrap.', { runtimeId: 'BASH' });
+    }
+    const usesCustomTrustBoundary = Boolean(configured && Object.values(configured).some((value) => value !== undefined));
+    let preflightProfile;
+    try {
+        preflightProfile = snapshotBashRuntimePreflightProfile(usesCustomTrustBoundary
+            ? {
+                profileId: configured?.profileId?.trim(),
+                bashPackageVersion: configured?.bashPackageVersion?.trim(),
+                bashSourceRevision: configured?.bashSourceRevision?.trim(),
+                wasmerSdkVersion: configured?.wasmerSdkVersion?.trim(),
+                wasmerSdkPackageIntegrity: configured?.wasmerSdkPackageIntegrity?.trim(),
+                manifestFingerprint: configured?.manifestFingerprint?.trim(),
+                manifestReceipt: configured?.manifestReceipt,
+                sdkJavaScriptReceipt: configured?.sdkJavaScriptReceipt,
+                wasmerWasmReceipt: configured?.wasmerWasmReceipt,
+                webcReceipt: configured?.webcReceipt
+            }
+            : WASM_BASH_RUNTIME_BUNDLE.profile);
+    }
+    catch (cause) {
+        throw new RuntimeConfigurationError('Bash runtime custom assets require one complete profile and receipt bundle.', { cause, runtimeId: 'BASH' });
+    }
+    const baseUrl = resolveBashBaseUrl(options, currentUrl);
+    const manifestUrl = configured?.manifestUrl
+        ? resolveConfiguredUrl(configured.manifestUrl, currentUrl)
+        : `${baseUrl}runtime-manifest.v2.json?v=${preflightProfile.manifestFingerprint}`;
+    const moduleUrl = configured?.moduleUrl
+        ? resolveConfiguredUrl(configured.moduleUrl, currentUrl)
+        : `${baseUrl}sdk/index.mjs.bin?v=${preflightProfile.sdkJavaScriptReceipt.sha256}`;
+    const wasmerWasmUrl = configured?.wasmerWasmUrl
+        ? resolveConfiguredUrl(configured.wasmerWasmUrl, currentUrl)
+        : `${baseUrl}sdk/wasmer_js_bg.wasm.gz.bin?v=${preflightProfile.wasmerWasmReceipt.sha256}`;
+    const webcUrl = configured?.webcUrl
+        ? resolveConfiguredUrl(configured.webcUrl, currentUrl)
+        : `${baseUrl}bash.webc.gz.bin?v=${preflightProfile.webcReceipt.sha256}`;
+    const identity = {
+        baseUrl,
+        manifestUrl,
+        moduleUrl,
+        wasmerWasmUrl,
+        webcUrl,
+        profile: preflightProfile
+    };
+    return {
+        baseUrl,
+        manifestUrl,
+        moduleUrl,
+        wasmerWasmUrl,
+        webcUrl,
+        manifestFingerprint: preflightProfile.manifestFingerprint,
+        preflightKey: JSON.stringify(identity),
+        preflightProfile
+    };
+}
+export function resolveSwiftBaseUrl(options, currentUrl = '') {
+    const configuredBaseUrl = (typeof options === 'object' && options?.swift?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_SWIFT_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return normalizeBaseUrl(configuredBaseUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/wasm-swift/`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-swift/`, currentUrl);
+    }
+    return normalizeBaseUrl('/wasm-swift/', currentUrl);
+}
+export function resolveSwiftWorkerUrl(options, currentUrl = '') {
+    const configuredWorkerUrl = (typeof options === 'object' && options?.swift?.workerUrl) ||
+        (publicEnv.PUBLIC_WASM_SWIFT_WORKER_URL || '').trim();
+    if (configuredWorkerUrl) {
+        return resolveConfiguredUrl(configuredWorkerUrl, currentUrl);
+    }
+    const configuredBaseUrl = (typeof options === 'object' && options?.swift?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_SWIFT_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return resolveConfiguredUrl(`${normalizeBaseUrl(configuredBaseUrl, currentUrl)}runner-worker.js`, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-swift/runner-worker.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-swift/runner-worker.js`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-swift/runner-worker.js', currentUrl);
+}
+export function resolveSwiftManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.swift?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_SWIFT_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl) {
+        return resolveConfiguredUrl(configuredManifestUrl, currentUrl);
+    }
+    const configuredBaseUrl = (typeof options === 'object' && options?.swift?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_SWIFT_BASE_URL || '').trim();
+    if (configuredBaseUrl) {
+        return resolveConfiguredUrl(`${normalizeBaseUrl(configuredBaseUrl, currentUrl)}runtime-manifest.v1.json`, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-swift/runtime-manifest.v1.json`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-swift/runtime-manifest.v1.json`, currentUrl);
+    }
+    return resolveConfiguredUrl('/wasm-swift/runtime-manifest.v1.json', currentUrl);
+}
+export function resolveSwiftRuntimeAssetConfig(options, currentUrl = '') {
+    return {
+        baseUrl: resolveSwiftBaseUrl(options, currentUrl),
+        workerUrl: resolveSwiftWorkerUrl(options, currentUrl),
+        manifestUrl: resolveSwiftManifestUrl(options, currentUrl)
+    };
+}
+export function resolveSqliteWasmUrl(options, currentUrl = '') {
+    const configuredWasmUrl = (typeof options === 'object' && options?.sqlite?.wasmUrl) ||
+        (publicEnv.PUBLIC_WASM_SQLITE_WASM_URL || '').trim();
+    if (configuredWasmUrl) {
+        return resolveConfiguredUrl(configuredWasmUrl, currentUrl);
+    }
+    return '';
+}
+function resolveStaticRuntimeModuleUrl(options, configuredModuleUrl, publicModuleUrl, folder, currentUrl = '') {
+    const moduleUrl = configuredModuleUrl || publicModuleUrl.trim();
+    if (moduleUrl)
+        return resolveConfiguredUrl(moduleUrl, currentUrl);
+    const rootUrl = typeof options === 'string' ? options : options?.rootUrl || '';
+    return resolveConfiguredUrl(`${normalizeRootUrl(rootUrl) || ''}/${folder}/runtime.mjs`, currentUrl);
+}
+export function resolveAssemblyScriptRuntimeModuleUrl(options, currentUrl = '') {
+    return resolveStaticRuntimeModuleUrl(options, typeof options === 'object' ? options?.assemblyscript?.moduleUrl : undefined, publicEnv.PUBLIC_WASM_ASSEMBLYSCRIPT_MODULE_URL || '', 'wasm-assemblyscript', currentUrl);
+}
+export function resolveDuckDbRuntimeModuleUrl(options, currentUrl = '') {
+    return resolveStaticRuntimeModuleUrl(options, typeof options === 'object' ? options?.duckdb?.moduleUrl : undefined, publicEnv.PUBLIC_WASM_DUCKDB_MODULE_URL || '', 'wasm-duckdb', currentUrl);
+}
+export function resolvePhpRuntimeModuleUrl(options, currentUrl = '') {
+    return resolveStaticRuntimeModuleUrl(options, typeof options === 'object' ? options?.php?.moduleUrl : undefined, publicEnv.PUBLIC_WASM_PHP_MODULE_URL || '', 'wasm-php', currentUrl);
+}
+export function resolveRubyRuntimeModuleUrl(options, currentUrl = '') {
+    return resolveRubyRuntimeAssetConfig(options, currentUrl).moduleUrl;
+}
+export function resolveSqliteRuntimeModuleUrl(options, currentUrl = '') {
+    return resolveStaticRuntimeModuleUrl(options, typeof options === 'object' ? options?.sqlite?.moduleUrl : undefined, publicEnv.PUBLIC_WASM_SQLITE_MODULE_URL || '', 'wasm-sqlite', currentUrl);
+}
+/** C3 uses one code-pinned compiler/worker receipt, served from this base URL. */
+export function resolveC3BaseUrl(options, currentUrl = '') {
+    const configured = (typeof options === 'object' && options?.c3?.baseUrl) ||
+        (publicEnv.PUBLIC_WASM_C3_BASE_URL || '').trim();
+    if (configured)
+        return normalizeBaseUrl(configured, currentUrl);
+    const root = typeof options === 'string' ? options : options?.rootUrl;
+    return normalizeBaseUrl(`${normalizeRootUrl(root || '') || ''}/wasm-c3/`, currentUrl);
+}