wasm-idle 1.0.0 → 1.0.4

package/dist/playground/loadingProgress.js

@@ -125,7 +125,8 @@ export function createLoadingProgressController({ onChange }) {
         measurementValue = Math.max(measurementValue, measurement.completed / measurement.total);
         state = {
             visible: true,
-            value: measurementValue,
+            // Keep one visible label monotonic when an estimate preceded its first byte sample.
+            value: Math.max(measurementValue, state.stage === event.label ? state.value : 0),
             stage: event.label,
             indeterminate: false
         };

package/dist/playground/ruby.js

@@ -252,6 +252,7 @@ class Ruby {
         }
         let limits;
         let nextConfig;
+        let startupContext;
         let nextAssetKey;
         let signal;
         let unbindPreSessionAbort = () => undefined;
@@ -265,39 +266,59 @@ class Ruby {
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
                 return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby runtime startup cancelled'));
             }
+            const workspace = validateExecutionWorkspace(_code, options.workspaceFiles ?? [], options.activePath ?? 'main.rb', {
+                ...options.workspaceLimits,
+                maxFileBytes: Math.min(options.workspaceLimits?.maxFileBytes ??
+                    DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
+                maxTotalBytes: Math.min(options.workspaceLimits?.maxTotalBytes ??
+                    DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
+            });
+            startupContext = {
+                args: [...resolveSandboxExecutionArgs('RUBY', _args, options).programArgs],
+                activePath: workspace.activePath ?? 'main.rb',
+                workspaceFiles: workspace.workspaceFiles.map((file) => ({
+                    path: file.path,
+                    content: file.content
+                }))
+            };
+            if (!this.isOperationActive(activeOperation) || signal?.aborted) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby runtime startup cancelled'));
+            }
             const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
             nextConfig = resolveRubyRuntimeAssetConfig(runtimeAssets, currentUrl);
             const effectiveMaxAssetBytes = Math.min(limits.maxAssetBytes, RUBY_MAX_ASSET_BYTES);
-            for (const [label, bytes, limit] of [
-                [
-                    'manifest',
-                    nextConfig.preflightProfile.manifestReceipt.bytes,
-                    Math.min(effectiveMaxAssetBytes, RUBY_MAX_MANIFEST_BYTES)
-                ],
-                [
-                    'module JavaScript',
-                    nextConfig.preflightProfile.moduleJavaScriptReceipt.bytes,
-                    Math.min(effectiveMaxAssetBytes, RUBY_MAX_MODULE_BYTES)
-                ],
-                [
-                    'Wasm storage',
-                    nextConfig.preflightProfile.wasmReceipt.bytes,
-                    effectiveMaxAssetBytes
-                ],
-                [
-                    'Wasm logical',
-                    nextConfig.preflightProfile.wasmReceipt.uncompressedBytes,
-                    effectiveMaxAssetBytes
-                ]
-            ]) {
-                if ((bytes ?? 0) > limit) {
-                    throw new AssetTooLargeError(`Ruby runtime ${label} exceeds the ${limit} byte limit`, {
-                        actual: bytes,
-                        limit,
-                        phase: 'asset',
-                        profileId: nextConfig.preflightProfile.profileId,
-                        runtimeId: 'RUBY'
-                    });
+            if (!nextConfig.splitStdlib) {
+                for (const [label, bytes, limit] of [
+                    [
+                        'manifest',
+                        nextConfig.preflightProfile.manifestReceipt.bytes,
+                        Math.min(effectiveMaxAssetBytes, RUBY_MAX_MANIFEST_BYTES)
+                    ],
+                    [
+                        'module JavaScript',
+                        nextConfig.preflightProfile.moduleJavaScriptReceipt.bytes,
+                        Math.min(effectiveMaxAssetBytes, RUBY_MAX_MODULE_BYTES)
+                    ],
+                    [
+                        'Wasm storage',
+                        nextConfig.preflightProfile.wasmReceipt.bytes,
+                        effectiveMaxAssetBytes
+                    ],
+                    [
+                        'Wasm logical',
+                        nextConfig.preflightProfile.wasmReceipt.uncompressedBytes,
+                        effectiveMaxAssetBytes
+                    ]
+                ]) {
+                    if ((bytes ?? 0) > limit) {
+                        throw new AssetTooLargeError(`Ruby runtime ${label} exceeds the ${limit} byte limit`, {
+                            actual: bytes,
+                            limit,
+                            phase: 'asset',
+                            profileId: nextConfig.preflightProfile.profileId,
+                            runtimeId: 'RUBY'
+                        });
+                    }
                 }
             }
             nextAssetKey = JSON.stringify([nextConfig.preflightKey, effectiveMaxAssetBytes]);
@@ -418,6 +439,7 @@ class Ruby {
                     worker.postMessage({
                         load: true,
                         runtimePreflight: delivery.payload,
+                        startupContext,
                         maxAssetBytes: Math.min(limits.maxAssetBytes, RUBY_MAX_ASSET_BYTES)
                     }, [...transferables]);
                 }

package/dist/playground/rubyAssets.d.ts

@@ -1,5 +1,5 @@
 import type { ResolvedRubyRuntimeAssetConfig } from './assets';
-import { type ExecutionLimits, type RubyRuntimePreflightPayload, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+import { type RubySplitPayload, type ExecutionLimits, type RubyRuntimePreflightPayload, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
 export interface RubyRuntimePreflightOptions {
     readonly limits?: Partial<ExecutionLimits>;
     readonly signal?: AbortSignal;
@@ -9,9 +9,9 @@ export interface RubyRuntimePreflightOptions {
 }
 export type RubyRuntimePreflightDeliveryState = 'available' | 'consumed' | 'retired';
 export interface RubyRuntimeOwnedPreflightDelivery {
-    readonly payload: RubyRuntimePreflightPayload;
+    readonly payload: RubyRuntimePreflightPayload | RubySplitPayload;
     readonly state: RubyRuntimePreflightDeliveryState;
-    consume(): readonly [ArrayBuffer, ArrayBuffer, ArrayBuffer];
+    consume(): readonly ArrayBuffer[];
     retire(): void;
 }
 /**
@@ -20,4 +20,4 @@ export interface RubyRuntimeOwnedPreflightDelivery {
  * whether postMessage succeeds; a consumed or retired delivery cannot be reused.
  */
 export declare function createRubyRuntimeOwnedPreflightDelivery(value: unknown): RubyRuntimeOwnedPreflightDelivery;
-export declare function preflightVerifiedRubyRuntimeAssets(config: ResolvedRubyRuntimeAssetConfig, options?: RubyRuntimePreflightOptions): Promise<RubyRuntimePreflightPayload>;
+export declare function preflightVerifiedRubyRuntimeAssets(config: ResolvedRubyRuntimeAssetConfig, options?: RubyRuntimePreflightOptions): Promise<RubyRuntimePreflightPayload | RubySplitPayload>;

package/dist/playground/rubyAssets.js

@@ -1,4 +1,4 @@
-import { preflightRubyRuntimeAssets, requireRubyRuntimePreflightPayload } from '@wasm-idle/core';
+import { preflightRubyRuntimeAssets, preflightRubySplitRuntimeAssets, RUBY_SPLIT_PROTOCOL, requireRubySplitPayload, requireRubyRuntimePreflightPayload } from '@wasm-idle/core';
 function isPlainFrozenRecord(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value) || !Object.isFrozen(value)) {
         return false;
@@ -24,11 +24,16 @@ export function createRubyRuntimeOwnedPreflightDelivery(value) {
     if (!isPlainFrozenRecord(value)) {
         throw new TypeError('Ruby runtime preflight delivery requires one frozen plain payload');
     }
-    const payload = requireRubyRuntimePreflightPayload(value);
+    const payload = Object.getOwnPropertyDescriptor(value, 'protocol')?.value === RUBY_SPLIT_PROTOCOL
+        ? requireRubySplitPayload(value)
+        : requireRubyRuntimePreflightPayload(value);
     const transferables = [
         requireOwnedWholeBuffer(payload.manifestBytes, 'manifest bytes'),
         requireOwnedWholeBuffer(payload.moduleJavaScriptBytes, 'module JavaScript bytes'),
-        requireOwnedWholeBuffer(payload.wasmBytes, 'Wasm bytes')
+        requireOwnedWholeBuffer(payload.wasmBytes, 'Wasm bytes'),
+        ...('stdlibBytes' in payload
+            ? [requireOwnedWholeBuffer(payload.stdlibBytes, 'stdlib bytes')]
+            : [])
     ];
     if (new Set(transferables).size !== transferables.length) {
         throw new TypeError('Ruby runtime preflight byte buffers must have unique ownership');
@@ -53,6 +58,8 @@ export function createRubyRuntimeOwnedPreflightDelivery(value) {
     });
 }
 export async function preflightVerifiedRubyRuntimeAssets(config, options = {}) {
+    if (config.splitStdlib)
+        return await preflightRubySplitRuntimeAssets({ baseUrl: config.baseUrl, ...options });
     return await preflightRubyRuntimeAssets({
         baseUrl: config.baseUrl,
         manifestUrl: config.manifestUrl,

package/dist/playground/sandbox.d.ts

@@ -45,4 +45,8 @@ export interface PlaygroundBinding {
     runtimeAssets: SandboxRuntimeAssets;
     terminalProps: PlaygroundTerminalProps;
     load: (language: string) => Promise<BoundSandbox>;
+    prewarm?: (language: string) => Promise<boolean>;
+    setPrewarmEnabled?: (enabled: boolean) => Promise<void>;
+    cancelPrewarm?: () => Promise<void>;
+    dispose?: () => Promise<void>;
 }

package/dist/playground/staticRuntimeModuleVersion.d.ts

@@ -1 +1 @@
-export declare const STATIC_RUNTIME_MODULE_VERSION = "53932f5e00aa7ad0";
+export declare const STATIC_RUNTIME_MODULE_VERSION = "14728c1583cce316";

package/dist/playground/staticRuntimeModuleVersion.js

@@ -1,2 +1,2 @@
 // Generated by scripts/build-static-runtime-modules.mjs.
-export const STATIC_RUNTIME_MODULE_VERSION = '53932f5e00aa7ad0';
+export const STATIC_RUNTIME_MODULE_VERSION = '14728c1583cce316';

package/dist/playground/typescript.js

@@ -3,7 +3,7 @@ import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS
 import {} from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
-import { WASM_TYPESCRIPT_MODULE_RECEIPT } from './wasmTypeScriptVersion';
+import { WASM_TYPESCRIPT_MODULE_RECEIPT, WASM_JAVASCRIPT_MODULE_RECEIPT } from './wasmTypeScriptVersion';
 import { WorkerSession } from './workerSession';
 import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
 const OUTPUT_ENCODER = new TextEncoder();
@@ -311,6 +311,7 @@ class TypeScriptSandbox {
         let signal;
         let limits;
         let nextModuleUrl;
+        let moduleReceipt = WASM_TYPESCRIPT_MODULE_RECEIPT;
         let progressTarget;
         let progressSet;
         let unbindPreSessionAbort = () => undefined;
@@ -328,7 +329,19 @@ class TypeScriptSandbox {
             if (typeof runtimeAssets === 'object' && runtimeAssets !== null) {
                 const configuredTypeScript = runtimeAssets.typescript;
                 this.requireOperationActive(activeOperation);
-                const configuredModuleUrl = configuredTypeScript?.moduleUrl;
+                const javascriptModuleUrl = this.language === 'JAVASCRIPT'
+                    ? configuredTypeScript?.javascriptModuleUrl
+                    : undefined;
+                this.requireOperationActive(activeOperation);
+                if (javascriptModuleUrl !== undefined && typeof javascriptModuleUrl !== 'string') {
+                    throw new TypeError('JavaScript runtime module URL must be a string');
+                }
+                const useJavascriptEntry = Boolean(javascriptModuleUrl);
+                const configuredModuleUrl = useJavascriptEntry
+                    ? javascriptModuleUrl
+                    : configuredTypeScript?.moduleUrl;
+                if (useJavascriptEntry)
+                    moduleReceipt = WASM_JAVASCRIPT_MODULE_RECEIPT;
                 this.requireOperationActive(activeOperation);
                 if (configuredModuleUrl !== undefined && typeof configuredModuleUrl !== 'string') {
                     throw new TypeError(`${this.languageLabel} runtime module URL must be a string`);
@@ -349,11 +362,11 @@ class TypeScriptSandbox {
                 nextModuleUrl = resolveTypeScriptModuleUrl(runtimeAssets, currentUrl);
                 this.requireOperationActive(activeOperation);
             }
-            if (WASM_TYPESCRIPT_MODULE_RECEIPT.bytes > limits.maxAssetBytes) {
+            if (moduleReceipt.bytes > limits.maxAssetBytes) {
                 throw new AssetTooLargeError(`${this.languageLabel} runtime module exceeds the ${limits.maxAssetBytes} byte limit`, {
                     runtimeId: this.language,
                     limit: limits.maxAssetBytes,
-                    actual: WASM_TYPESCRIPT_MODULE_RECEIPT.bytes
+                    actual: moduleReceipt.bytes
                 });
             }
             progressTarget = progress;
@@ -465,7 +478,7 @@ class TypeScriptSandbox {
                     worker.postMessage({
                         load: true,
                         moduleUrl: nextModuleUrl,
-                        moduleReceipt: { ...WASM_TYPESCRIPT_MODULE_RECEIPT },
+                        moduleReceipt: { ...moduleReceipt },
                         maxAssetBytes: limits.maxAssetBytes
                     });
                 }

package/dist/playground/wasmDotnetVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_DOTNET_ASSET_VERSION = "9af2460d9bb92f76";
+export declare const WASM_DOTNET_ASSET_VERSION = "8f1f986689faf541";

package/dist/playground/wasmDotnetVersion.js

@@ -1 +1 @@
-export const WASM_DOTNET_ASSET_VERSION = '9af2460d9bb92f76';
+export const WASM_DOTNET_ASSET_VERSION = '8f1f986689faf541';

package/dist/playground/wasmGoVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_GO_ASSET_VERSION = "5ede7c5820d8d808";
+export declare const WASM_GO_ASSET_VERSION = "ec36de55be7334e4";

package/dist/playground/wasmGoVersion.js

@@ -1 +1 @@
-export const WASM_GO_ASSET_VERSION = '5ede7c5820d8d808';
+export const WASM_GO_ASSET_VERSION = 'ec36de55be7334e4';

package/dist/playground/wasmRustVersion.d.ts

@@ -1,8 +1,8 @@
 export declare const WASM_RUST_RUNTIME_PROFILE: Readonly<{
-    readonly profileId: "wasm-rust-e08b681dc178ea1f48c632c7a03746589f0340952b225d006b198aa958727789";
+    readonly profileId: "wasm-rust-b9d5b748f2d5e53045ef55890676e8ecb81a8ea07a31dfd20e70888c807bf9a6";
     readonly protocolVersion: 1;
     readonly manifestPath: "runtime/runtime-manifest.v3.json";
-    readonly manifestFingerprint: "e08b681dc178ea1f48c632c7a03746589f0340952b225d006b198aa958727789";
+    readonly manifestFingerprint: "b9d5b748f2d5e53045ef55890676e8ecb81a8ea07a31dfd20e70888c807bf9a6";
     readonly manifestReceipt: {
         readonly bytes: 6185;
         readonly sha256: "30b210003632395a1effd19f7a46565d5f8c52a9d3a28a310fa24219f97a5a9a";
@@ -383,12 +383,12 @@ export declare const WASM_RUST_EXECUTABLE_GRAPH_PROFILE: Readonly<{
                 readonly encoding: "identity";
             };
             readonly storage: {
-                readonly bytes: 21326;
-                readonly sha256: "742fbfb33fc0eb89249c49832fbe57c33c392b86d9faaa8688f5213ef95aeae8";
+                readonly bytes: 21605;
+                readonly sha256: "19dd922fd7493a80cb46e9113368376dd8ffce32282d433caaaaebae4d5388f4";
             };
             readonly logical: {
-                readonly bytes: 21326;
-                readonly sha256: "742fbfb33fc0eb89249c49832fbe57c33c392b86d9faaa8688f5213ef95aeae8";
+                readonly bytes: 21605;
+                readonly sha256: "19dd922fd7493a80cb46e9113368376dd8ffce32282d433caaaaebae4d5388f4";
             };
             readonly imports: readonly [{
                 readonly kind: "static";
@@ -422,6 +422,14 @@ export declare const WASM_RUST_EXECUTABLE_GRAPH_PROFILE: Readonly<{
                 readonly kind: "static";
                 readonly specifier: "./runtime-manifest.js";
                 readonly target: "runtime-manifest.js";
+            }, {
+                readonly kind: "static";
+                readonly specifier: "./rustc-module-service.js";
+                readonly target: "rustc-module-service.js";
+            }, {
+                readonly kind: "static";
+                readonly specifier: "./rustc-module.js";
+                readonly target: "rustc-module.js";
             }, {
                 readonly kind: "static";
                 readonly specifier: "./rustc-runtime.js";
@@ -448,12 +456,12 @@ export declare const WASM_RUST_EXECUTABLE_GRAPH_PROFILE: Readonly<{
                 readonly encoding: "identity";
             };
             readonly storage: {
-                readonly bytes: 33077;
-                readonly sha256: "57610f3dd5babfb44e40a29bb40c1de78b1adfff8b9d1ce7dd5c83a991b9d865";
+                readonly bytes: 33998;
+                readonly sha256: "0a6c0bc4483c00265a7ecc228faa5f4252831b5953f0a9a00a685d8fcf4f0825";
             };
             readonly logical: {
-                readonly bytes: 33077;
-                readonly sha256: "57610f3dd5babfb44e40a29bb40c1de78b1adfff8b9d1ce7dd5c83a991b9d865";
+                readonly bytes: 33998;
+                readonly sha256: "0a6c0bc4483c00265a7ecc228faa5f4252831b5953f0a9a00a685d8fcf4f0825";
             };
             readonly imports: readonly [{
                 readonly kind: "static";
@@ -491,6 +499,10 @@ export declare const WASM_RUST_EXECUTABLE_GRAPH_PROFILE: Readonly<{
                 readonly kind: "static";
                 readonly specifier: "./runtime-manifest.js";
                 readonly target: "runtime-manifest.js";
+            }, {
+                readonly kind: "static";
+                readonly specifier: "./rustc-module-service.js";
+                readonly target: "rustc-module-service.js";
             }, {
                 readonly kind: "static";
                 readonly specifier: "./rustc-runtime.js";
@@ -662,6 +674,48 @@ export declare const WASM_RUST_EXECUTABLE_GRAPH_PROFILE: Readonly<{
             readonly assets: readonly [];
             readonly externals: readonly [];
         };
+        readonly 'rustc-module-service.js': {
+            readonly delivery: {
+                readonly storagePath: "rustc-module-service.js.bin";
+                readonly encoding: "identity";
+            };
+            readonly storage: {
+                readonly bytes: 4926;
+                readonly sha256: "643e87810870eadb9489f4161f2132a158e37c1e343426c58e04e3482e1d7045";
+            };
+            readonly logical: {
+                readonly bytes: 4926;
+                readonly sha256: "643e87810870eadb9489f4161f2132a158e37c1e343426c58e04e3482e1d7045";
+            };
+            readonly imports: readonly [{
+                readonly kind: "static";
+                readonly specifier: "./runtime-asset.js";
+                readonly target: "runtime-asset.js";
+            }, {
+                readonly kind: "static";
+                readonly specifier: "./rustc-module.js";
+                readonly target: "rustc-module.js";
+            }];
+            readonly assets: readonly [];
+            readonly externals: readonly [];
+        };
+        readonly 'rustc-module.js': {
+            readonly delivery: {
+                readonly storagePath: "rustc-module.js.bin";
+                readonly encoding: "identity";
+            };
+            readonly storage: {
+                readonly bytes: 711;
+                readonly sha256: "81dee74032dd10187e9b576f2d2fe9291cee1ea6a829d0db37429dabd06c0d1e";
+            };
+            readonly logical: {
+                readonly bytes: 711;
+                readonly sha256: "81dee74032dd10187e9b576f2d2fe9291cee1ea6a829d0db37429dabd06c0d1e";
+            };
+            readonly imports: readonly [];
+            readonly assets: readonly [];
+            readonly externals: readonly [];
+        };
         readonly 'rustc-runtime.js': {
             readonly delivery: {
                 readonly storagePath: "rustc-runtime.js.bin";
@@ -1301,6 +1355,6 @@ export declare const WASM_RUST_EXECUTABLE_GRAPH_PROFILE: Readonly<{
             readonly externals: readonly [];
         };
     };
-    readonly fingerprint: "dc7ad407a4190ea84f80ad5589d86d6c704aa2c982d211f6ddcaed558bc57f65";
+    readonly fingerprint: "0c75869e3318fec8de28ba3732a65a4db9e92993cb517339fb729502e689f67f";
 }>;
-export declare const WASM_RUST_ASSET_VERSION: "e08b681dc178ea1f48c632c7a03746589f0340952b225d006b198aa958727789";
+export declare const WASM_RUST_ASSET_VERSION: "b9d5b748f2d5e53045ef55890676e8ecb81a8ea07a31dfd20e70888c807bf9a6";

package/dist/playground/wasmRustVersion.js

@@ -1,8 +1,8 @@
 export const WASM_RUST_RUNTIME_PROFILE = Object.freeze({
-    profileId: 'wasm-rust-e08b681dc178ea1f48c632c7a03746589f0340952b225d006b198aa958727789',
+    profileId: 'wasm-rust-b9d5b748f2d5e53045ef55890676e8ecb81a8ea07a31dfd20e70888c807bf9a6',
     protocolVersion: 1,
     manifestPath: 'runtime/runtime-manifest.v3.json',
-    manifestFingerprint: 'e08b681dc178ea1f48c632c7a03746589f0340952b225d006b198aa958727789',
+    manifestFingerprint: 'b9d5b748f2d5e53045ef55890676e8ecb81a8ea07a31dfd20e70888c807bf9a6',
     manifestReceipt: {
         bytes: 6185,
         sha256: '30b210003632395a1effd19f7a46565d5f8c52a9d3a28a310fa24219f97a5a9a'
@@ -427,12 +427,12 @@ export const WASM_RUST_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
                 encoding: 'identity'
             },
             storage: {
-                bytes: 21326,
-                sha256: '742fbfb33fc0eb89249c49832fbe57c33c392b86d9faaa8688f5213ef95aeae8'
+                bytes: 21605,
+                sha256: '19dd922fd7493a80cb46e9113368376dd8ffce32282d433caaaaebae4d5388f4'
             },
             logical: {
-                bytes: 21326,
-                sha256: '742fbfb33fc0eb89249c49832fbe57c33c392b86d9faaa8688f5213ef95aeae8'
+                bytes: 21605,
+                sha256: '19dd922fd7493a80cb46e9113368376dd8ffce32282d433caaaaebae4d5388f4'
             },
             imports: [
                 {
@@ -475,6 +475,16 @@ export const WASM_RUST_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
                     specifier: './runtime-manifest.js',
                     target: 'runtime-manifest.js'
                 },
+                {
+                    kind: 'static',
+                    specifier: './rustc-module-service.js',
+                    target: 'rustc-module-service.js'
+                },
+                {
+                    kind: 'static',
+                    specifier: './rustc-module.js',
+                    target: 'rustc-module.js'
+                },
                 {
                     kind: 'static',
                     specifier: './rustc-runtime.js',
@@ -505,12 +515,12 @@ export const WASM_RUST_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
                 encoding: 'identity'
             },
             storage: {
-                bytes: 33077,
-                sha256: '57610f3dd5babfb44e40a29bb40c1de78b1adfff8b9d1ce7dd5c83a991b9d865'
+                bytes: 33998,
+                sha256: '0a6c0bc4483c00265a7ecc228faa5f4252831b5953f0a9a00a685d8fcf4f0825'
             },
             logical: {
-                bytes: 33077,
-                sha256: '57610f3dd5babfb44e40a29bb40c1de78b1adfff8b9d1ce7dd5c83a991b9d865'
+                bytes: 33998,
+                sha256: '0a6c0bc4483c00265a7ecc228faa5f4252831b5953f0a9a00a685d8fcf4f0825'
             },
             imports: [
                 {
@@ -558,6 +568,11 @@ export const WASM_RUST_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
                     specifier: './runtime-manifest.js',
                     target: 'runtime-manifest.js'
                 },
+                {
+                    kind: 'static',
+                    specifier: './rustc-module-service.js',
+                    target: 'rustc-module-service.js'
+                },
                 {
                     kind: 'static',
                     specifier: './rustc-runtime.js',
@@ -745,6 +760,51 @@ export const WASM_RUST_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
             assets: [],
             externals: []
         },
+        'rustc-module-service.js': {
+            delivery: {
+                storagePath: 'rustc-module-service.js.bin',
+                encoding: 'identity'
+            },
+            storage: {
+                bytes: 4926,
+                sha256: '643e87810870eadb9489f4161f2132a158e37c1e343426c58e04e3482e1d7045'
+            },
+            logical: {
+                bytes: 4926,
+                sha256: '643e87810870eadb9489f4161f2132a158e37c1e343426c58e04e3482e1d7045'
+            },
+            imports: [
+                {
+                    kind: 'static',
+                    specifier: './runtime-asset.js',
+                    target: 'runtime-asset.js'
+                },
+                {
+                    kind: 'static',
+                    specifier: './rustc-module.js',
+                    target: 'rustc-module.js'
+                }
+            ],
+            assets: [],
+            externals: []
+        },
+        'rustc-module.js': {
+            delivery: {
+                storagePath: 'rustc-module.js.bin',
+                encoding: 'identity'
+            },
+            storage: {
+                bytes: 711,
+                sha256: '81dee74032dd10187e9b576f2d2fe9291cee1ea6a829d0db37429dabd06c0d1e'
+            },
+            logical: {
+                bytes: 711,
+                sha256: '81dee74032dd10187e9b576f2d2fe9291cee1ea6a829d0db37429dabd06c0d1e'
+            },
+            imports: [],
+            assets: [],
+            externals: []
+        },
         'rustc-runtime.js': {
             delivery: {
                 storagePath: 'rustc-runtime.js.bin',
@@ -1453,6 +1513,6 @@ export const WASM_RUST_EXECUTABLE_GRAPH_PROFILE = Object.freeze({
             externals: []
         }
     },
-    fingerprint: 'dc7ad407a4190ea84f80ad5589d86d6c704aa2c982d211f6ddcaed558bc57f65'
+    fingerprint: '0c75869e3318fec8de28ba3732a65a4db9e92993cb517339fb729502e689f67f'
 });
 export const WASM_RUST_ASSET_VERSION = WASM_RUST_RUNTIME_PROFILE.manifestFingerprint;

package/dist/playground/wasmTypeScriptVersion.d.ts

@@ -1,5 +1,9 @@
-export declare const WASM_TYPESCRIPT_ASSET_VERSION = "1ed3672d1170db47";
+export declare const WASM_TYPESCRIPT_ASSET_VERSION = "39caba34204ca2bc";
 export declare const WASM_TYPESCRIPT_MODULE_RECEIPT: Readonly<{
-    bytes: 3766184;
-    sha256: "e7e38f188d8c5bf13d21e0b701723b9ec9c3c12b4226aa51c933497f09c1b874";
+    bytes: 3766190;
+    sha256: "483aedcb29a0aee52f4167d4bbbb6070d5d187986952a17c849ad65a29374dde";
+}>;
+export declare const WASM_JAVASCRIPT_MODULE_RECEIPT: Readonly<{
+    bytes: 35829;
+    sha256: "3afa49e47296ad7d97f43a80500d95e55321d197b3ce95ddb823f10e91188c83";
 }>;

package/dist/playground/wasmTypeScriptVersion.js

@@ -1,5 +1,9 @@
-export const WASM_TYPESCRIPT_ASSET_VERSION = '1ed3672d1170db47';
+export const WASM_TYPESCRIPT_ASSET_VERSION = '39caba34204ca2bc';
 export const WASM_TYPESCRIPT_MODULE_RECEIPT = Object.freeze({
-    bytes: 3766184,
-    sha256: 'e7e38f188d8c5bf13d21e0b701723b9ec9c3c12b4226aa51c933497f09c1b874'
+    bytes: 3766190,
+    sha256: '483aedcb29a0aee52f4167d4bbbb6070d5d187986952a17c849ad65a29374dde'
+});
+export const WASM_JAVASCRIPT_MODULE_RECEIPT = Object.freeze({
+    bytes: 35829,
+    sha256: '3afa49e47296ad7d97f43a80500d95e55321d197b3ce95ddb823f10e91188c83'
 });

package/dist/playground/worker/assets.js

@@ -1,3 +1,4 @@
+import { createBoundedAssetResponse } from './boundedAssetResponse';
 const decoder = new TextDecoder();
 const DEFAULT_MAX_ASSET_BYTES = 128 * 1024 * 1024;
 const DEFAULT_STREAM_BUFFER_BYTES = 64 * 1024;
@@ -124,18 +125,24 @@ const loadAssetFromBridge = async (asset) => {
         });
     });
 };
-const loadAssetFromUrl = async (url, asset, integrity) => {
+const fetchAssetFromUrl = async (url, asset, integrity, signal) => {
     const requestUrl = trackedAssetUrl(url);
     if (!requestUrl || trackedAssetName(requestUrl) !== asset || !activeConfig) {
         throw new Error('Untracked runtime asset request');
     }
     const maxAssetBytes = activeConfig.maxAssetBytes ?? DEFAULT_MAX_ASSET_BYTES;
+    signal?.throwIfAborted();
     const response = await originalFetch(requestUrl, {
         credentials: 'omit',
         redirect: 'error',
         referrerPolicy: 'no-referrer',
-        ...(integrity ? { integrity } : {})
+        ...(integrity ? { integrity } : {}),
+        ...(signal ? { signal } : {})
     });
+    if (signal?.aborted) {
+        cancelResponseBody(response, signal.reason);
+        signal.throwIfAborted();
+    }
     if (response.url) {
         let responseUrl;
         try {
@@ -174,6 +181,10 @@ const loadAssetFromUrl = async (url, asset, integrity) => {
         throw error;
     }
     const mimeType = response.headers.get('content-type') || undefined;
+    return { response, maxAssetBytes, total, mimeType };
+};
+const loadAssetFromUrl = async (url, asset, integrity) => {
+    const { response, maxAssetBytes, total, mimeType } = await fetchAssetFromUrl(url, asset, integrity);
     if (!response.body) {
         const bytes = new Uint8Array(await response.arrayBuffer());
         if (bytes.byteLength > maxAssetBytes) {
@@ -401,11 +412,27 @@ function installRuntimeAssetInterceptors() {
             }
             return originalFetch(input, init);
         }
-        const requestIntegrity = init?.integrity ??
-            (typeof Request !== 'undefined' && input instanceof Request
-                ? input.integrity
-                : undefined);
-        return createTrackedResponse(await loadTrackedAsset(resolvedUrl, typeof requestIntegrity === 'string' ? requestIntegrity : undefined));
+        const request = typeof Request !== 'undefined' && input instanceof Request ? input : undefined;
+        const requestIntegrity = init?.integrity ?? request?.integrity;
+        const integrity = typeof requestIntegrity === 'string' ? requestIntegrity : undefined;
+        const method = (init?.method ?? request?.method ?? 'GET').toUpperCase();
+        if (activeConfig?.useAssetBridge === false &&
+            method === 'GET' &&
+            new URL(resolvedUrl).pathname.endsWith('.wasm')) {
+            const asset = trackedAssetName(resolvedUrl);
+            const signal = (init?.signal === undefined ? request?.signal : init.signal) ?? undefined;
+            const { response, maxAssetBytes, total } = await fetchAssetFromUrl(resolvedUrl, asset, integrity, signal);
+            return createBoundedAssetResponse(response, {
+                asset,
+                maxAssetBytes,
+                total,
+                signal,
+                onProgress: (loaded, total) => self.postMessage({ assetProgress: { asset, loaded, total } })
+            });
+        }
+        // Custom host bridges must finish receipt verification before exposing bytes.
+        // Archives, module imports, and XHR consumers retain their buffered contracts.
+        return createTrackedResponse(await loadTrackedAsset(resolvedUrl, integrity));
     });
     installTrackedFetch();
 }