wasm-idle 0.7.2 → 1.0.0

package/dist/playground/jPreflight.js

@@ -0,0 +1,372 @@
+import { AssetIntegrityError, AssetTooLargeError, CancelledError, RuntimeConfigurationError, TimeoutError, UnsupportedBrowserFeatureError, isWasmIdleError, preflightRuntimeAssets, resolveExecutionLimits, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+export const J_PREFLIGHT_PROTOCOL = 'wasm-idle-j-preflight';
+export const J_PREFLIGHT_PROTOCOL_VERSION = 1;
+export const J_PREFLIGHT_RUNTIME_ID = 'J';
+const MAX_MANIFEST_BYTES = 64 * 1024;
+const VERIFIED_WASM_STORAGE_PATH = 'jamalgam.wasm.gz.bin';
+export async function preflightJRuntimeAssets(request) {
+    if (!request || typeof request !== 'object') {
+        throw new RuntimeConfigurationError('J runtime preflight request is required', {
+            phase: 'asset',
+            runtimeId: J_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    let baseUrl;
+    let manifestUrl;
+    try {
+        baseUrl = new URL(request.baseUrl);
+        if (!baseUrl.pathname.endsWith('/'))
+            baseUrl.pathname += '/';
+        manifestUrl = new URL(request.manifestUrl, baseUrl);
+    }
+    catch (error) {
+        throw new RuntimeConfigurationError('J runtime asset URLs are invalid', {
+            cause: error,
+            phase: 'asset',
+            runtimeId: J_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    if ((baseUrl.protocol !== 'https:' && baseUrl.protocol !== 'http:') ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('J runtime base must be a credential-free HTTP(S) directory URL without a query or fragment', { phase: 'asset', runtimeId: J_PREFLIGHT_RUNTIME_ID });
+    }
+    if ((manifestUrl.protocol !== 'https:' && manifestUrl.protocol !== 'http:') ||
+        manifestUrl.username ||
+        manifestUrl.password ||
+        manifestUrl.hash ||
+        manifestUrl.origin !== baseUrl.origin ||
+        !manifestUrl.pathname.startsWith(baseUrl.pathname)) {
+        throw new RuntimeConfigurationError('J runtime manifest must be an HTTP(S) asset beneath the configured runtime base', { phase: 'asset', runtimeId: J_PREFLIGHT_RUNTIME_ID });
+    }
+    const manifestPath = manifestUrl.pathname.slice(baseUrl.pathname.length);
+    if (!manifestPath ||
+        manifestPath.includes('\\') ||
+        manifestPath.includes('\0') ||
+        manifestPath.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new RuntimeConfigurationError('J runtime manifest path must be a normalized file beneath the runtime base', { phase: 'asset', runtimeId: J_PREFLIGHT_RUNTIME_ID });
+    }
+    if (manifestPath === 'jamalgam.js' || manifestPath === VERIFIED_WASM_STORAGE_PATH) {
+        throw new RuntimeConfigurationError('J runtime manifest and executable asset paths must be distinct', { phase: 'asset', runtimeId: J_PREFLIGHT_RUNTIME_ID });
+    }
+    const profile = request.profile;
+    if (!profile ||
+        typeof profile !== 'object' ||
+        typeof profile.profileId !== 'string' ||
+        !/^jsoftware-j-playground-[A-Za-z0-9._-]+$/u.test(profile.profileId) ||
+        typeof profile.sourceRevision !== 'string' ||
+        !/^[A-Za-z0-9:;._-]+$/u.test(profile.sourceRevision) ||
+        typeof profile.manifestFingerprint !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(profile.manifestFingerprint)) {
+        throw new RuntimeConfigurationError('J runtime preflight profile is invalid', {
+            phase: 'asset',
+            runtimeId: J_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    for (const [label, receipt] of [
+        ['manifest', profile.manifestReceipt],
+        ['module', profile.moduleReceipt]
+    ]) {
+        if (!receipt ||
+            typeof receipt !== 'object' ||
+            !Number.isSafeInteger(receipt.bytes) ||
+            (receipt.bytes ?? 0) <= 0 ||
+            typeof receipt.sha256 !== 'string' ||
+            !/^[a-f0-9]{64}$/u.test(receipt.sha256)) {
+            throw new RuntimeConfigurationError(`J runtime ${label} preflight receipt is invalid`, {
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+    }
+    const wasmReceipt = profile.wasmReceipt;
+    if (!wasmReceipt ||
+        typeof wasmReceipt !== 'object' ||
+        !Number.isSafeInteger(wasmReceipt.bytes) ||
+        (wasmReceipt.bytes ?? 0) <= 0 ||
+        typeof wasmReceipt.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(wasmReceipt.sha256) ||
+        !Number.isSafeInteger(wasmReceipt.uncompressedBytes) ||
+        (wasmReceipt.uncompressedBytes ?? 0) <= 0 ||
+        typeof wasmReceipt.uncompressedSha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(wasmReceipt.uncompressedSha256)) {
+        throw new RuntimeConfigurationError('J runtime Wasm preflight receipt is invalid', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: J_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const limits = resolveExecutionLimits(request.limits);
+    const oversized = [
+        [
+            'manifest',
+            profile.manifestReceipt.bytes,
+            Math.min(MAX_MANIFEST_BYTES, limits.maxAssetBytes)
+        ],
+        ['module', profile.moduleReceipt.bytes, limits.maxAssetBytes],
+        ['compressed Wasm', wasmReceipt.bytes, limits.maxAssetBytes],
+        ['logical Wasm', wasmReceipt.uncompressedBytes, limits.maxAssetBytes]
+    ];
+    for (const [label, bytes, limit] of oversized) {
+        if (bytes > limit) {
+            throw new AssetTooLargeError(`J runtime ${label} exceeds the ${limit} byte limit`, {
+                actual: bytes,
+                limit,
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+    }
+    if (typeof DecompressionStream !== 'function') {
+        throw new UnsupportedBrowserFeatureError('DecompressionStream(gzip)', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: J_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const expectedManifestQuery = `?v=${profile.manifestFingerprint}`;
+    if (manifestUrl.search && manifestUrl.search !== expectedManifestQuery) {
+        throw new RuntimeConfigurationError('J runtime manifest query must be the pinned manifest fingerprint cache-buster', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: J_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const manifestRequestUrl = new URL(manifestUrl);
+    if (!manifestRequestUrl.search) {
+        manifestRequestUrl.searchParams.set('v', profile.manifestFingerprint);
+    }
+    const moduleRequestUrl = new URL('jamalgam.js', baseUrl);
+    moduleRequestUrl.searchParams.set('v', profile.moduleReceipt.sha256);
+    const wasmRequestUrl = new URL(VERIFIED_WASM_STORAGE_PATH, baseUrl);
+    wasmRequestUrl.searchParams.set('v', wasmReceipt.sha256);
+    const registry = {
+        schemaVersion: 2,
+        manifestId: 'wasm-idle/j-preflight',
+        revision: profile.manifestFingerprint,
+        runtimes: [
+            {
+                runtimeId: J_PREFLIGHT_RUNTIME_ID,
+                identity: {
+                    languageId: 'J',
+                    implementationId: 'jsoftware/j-playground',
+                    implementationVersion: profile.sourceRevision,
+                    profile: {
+                        profileId: profile.profileId,
+                        manifestSchemaVersion: 2,
+                        manifestSha256: profile.manifestReceipt.sha256,
+                        protocolVersion: J_PREFLIGHT_PROTOCOL_VERSION,
+                        trustProfileId: 'wasm-idle-static-worker-v1',
+                        trustProfileSchemaVersion: 1
+                    }
+                },
+                capabilities: {
+                    stdin: 'streaming',
+                    workspace: false,
+                    abort: true,
+                    artifacts: false,
+                    streamingOutput: true
+                },
+                workerLifetime: { mode: 'per-run' },
+                requiredBrowserFeatures: ['wasm', 'decompression-stream'],
+                assetRoot: '.',
+                assets: [
+                    {
+                        key: 'manifest',
+                        path: manifestPath,
+                        compressedSha256: profile.manifestReceipt.sha256,
+                        uncompressedSha256: profile.manifestReceipt.sha256,
+                        compressedBytes: profile.manifestReceipt.bytes,
+                        uncompressedBytes: profile.manifestReceipt.bytes,
+                        mediaType: 'application/json',
+                        encoding: 'identity'
+                    },
+                    {
+                        key: 'module',
+                        path: 'jamalgam.js',
+                        compressedSha256: profile.moduleReceipt.sha256,
+                        uncompressedSha256: profile.moduleReceipt.sha256,
+                        compressedBytes: profile.moduleReceipt.bytes,
+                        uncompressedBytes: profile.moduleReceipt.bytes,
+                        mediaType: 'text/javascript',
+                        encoding: 'identity'
+                    },
+                    {
+                        key: 'wasm',
+                        path: VERIFIED_WASM_STORAGE_PATH,
+                        compressedSha256: wasmReceipt.sha256,
+                        uncompressedSha256: wasmReceipt.uncompressedSha256,
+                        compressedBytes: wasmReceipt.bytes,
+                        uncompressedBytes: wasmReceipt.uncompressedBytes,
+                        mediaType: 'application/wasm',
+                        encoding: 'gzip'
+                    }
+                ],
+                contracts: {
+                    routeId: 'j',
+                    runtimeAssetKey: 'j',
+                    documentationId: 'J',
+                    syncTarget: 'sync:wasm-j',
+                    browserTestId: 'browser:j'
+                }
+            }
+        ]
+    };
+    const controller = new AbortController();
+    let timedOut = false;
+    const abortFromCaller = () => controller.abort(request.signal?.reason);
+    request.signal?.addEventListener('abort', abortFromCaller, { once: true });
+    if (request.signal?.aborted)
+        abortFromCaller();
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new DOMException('J runtime preflight timed out', 'TimeoutError'));
+    }, limits.assetTimeoutMs);
+    try {
+        const preflight = await preflightRuntimeAssets({
+            manifest: registry,
+            runtimeId: J_PREFLIGHT_RUNTIME_ID,
+            rootUrl: baseUrl,
+            assetUrls: {
+                manifest: manifestRequestUrl,
+                module: moduleRequestUrl,
+                wasm: wasmRequestUrl
+            },
+            fetch: request.fetch,
+            signal: controller.signal,
+            limits,
+            maxConcurrentDownloads: 3,
+            reportProgress: request.reportProgress
+        });
+        const manifestAsset = preflight.assets.manifest;
+        const moduleAsset = preflight.assets.module;
+        const wasmAsset = preflight.assets.wasm;
+        if (!manifestAsset || !moduleAsset || !wasmAsset) {
+            throw new RuntimeConfigurationError('J runtime preflight returned an incomplete asset set', {
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        if (wasmAsset.bytes[0] !== 0x1f || wasmAsset.bytes[1] !== 0x8b) {
+            throw new AssetIntegrityError('J runtime Wasm storage asset is not gzip data', {
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        const compressedBody = new Response(Uint8Array.from(wasmAsset.bytes)).body;
+        if (!compressedBody) {
+            throw new UnsupportedBrowserFeatureError('ReadableStream response bodies', {
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        const stream = compressedBody.pipeThrough(new DecompressionStream('gzip'));
+        const reader = stream.getReader();
+        const wasmBytes = new Uint8Array(wasmReceipt.uncompressedBytes);
+        let offset = 0;
+        const cancelDecompression = () => {
+            try {
+                void reader.cancel(controller.signal.reason).catch(() => undefined);
+            }
+            catch {
+                // Preserve the cancellation or integrity failure that stopped decompression.
+            }
+        };
+        controller.signal.addEventListener('abort', cancelDecompression, { once: true });
+        try {
+            for (;;) {
+                if (controller.signal.aborted)
+                    throw controller.signal.reason;
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (offset + value.byteLength > wasmBytes.byteLength) {
+                    const error = new AssetIntegrityError('J runtime Wasm gzip output exceeds its logical receipt', { profileId: profile.profileId, runtimeId: J_PREFLIGHT_RUNTIME_ID });
+                    try {
+                        await reader.cancel(error);
+                    }
+                    catch {
+                        // Preserve the expansion-limit failure.
+                    }
+                    throw error;
+                }
+                wasmBytes.set(value, offset);
+                offset += value.byteLength;
+                request.reportDecompressionProgress?.(offset, wasmBytes.byteLength);
+            }
+        }
+        catch (error) {
+            if (controller.signal.aborted || isWasmIdleError(error))
+                throw error;
+            throw new AssetIntegrityError('J runtime Wasm gzip decompression failed', {
+                cause: error,
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        finally {
+            controller.signal.removeEventListener('abort', cancelDecompression);
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                // Cancellation may already have detached the stream reader.
+            }
+        }
+        if (offset !== wasmBytes.byteLength) {
+            throw new AssetIntegrityError('J runtime Wasm gzip output is shorter than its logical receipt', {
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        await verifyRuntimeAssetIntegrity({
+            asset: 'jamalgam.wasm',
+            bytes: wasmBytes,
+            expected: wasmReceipt,
+            stage: 'uncompressed',
+            mimeType: 'application/wasm',
+            profileId: profile.profileId,
+            runtimeId: J_PREFLIGHT_RUNTIME_ID
+        });
+        return Object.freeze({
+            protocol: J_PREFLIGHT_PROTOCOL,
+            protocolVersion: J_PREFLIGHT_PROTOCOL_VERSION,
+            profileId: profile.profileId,
+            sourceRevision: profile.sourceRevision,
+            manifestFingerprint: profile.manifestFingerprint,
+            manifestBytes: Uint8Array.from(manifestAsset.bytes),
+            moduleBytes: Uint8Array.from(moduleAsset.bytes),
+            wasmBytes
+        });
+    }
+    catch (error) {
+        if (timedOut) {
+            throw new TimeoutError(`J runtime preflight timed out after ${limits.assetTimeoutMs} ms`, {
+                cause: error,
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID,
+                timeoutMs: limits.assetTimeoutMs
+            });
+        }
+        if (request.signal?.aborted) {
+            throw new CancelledError('J runtime preflight cancelled', {
+                cause: request.signal.reason,
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: J_PREFLIGHT_RUNTIME_ID
+            });
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+        request.signal?.removeEventListener('abort', abortFromCaller);
+    }
+}

package/dist/playground/janet.d.ts

@@ -0,0 +1,5 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+declare class Janet extends StaticWorkerRuntimeSandbox {
+    constructor();
+}
+export default Janet;

package/dist/playground/janet.js

@@ -0,0 +1,64 @@
+import { resolveJanetRuntimeAssetConfig } from './assets';
+import { preflightStaticRuntimeAssetsInWorker } from './staticRuntimePreflight';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, snapshotJanetRuntimePreflightProfile } from '@wasm-idle/core';
+class Janet extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            displayName: 'Janet',
+            languageId: 'JANET',
+            defaultActivePath: 'main.janet',
+            moduleWorker: true,
+            workerLifetime: { mode: 'per-run' },
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(?:getline|stdin|file\/read)\b/i
+            },
+            inlineVerifiedWorker: true,
+            runtimePreflightDelivery: 'transfer-owned',
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveJanetRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotJanetRuntimePreflightProfile(resolved.preflightProfile);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Janet runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'JANET' });
+                }
+                return { ...resolved, preflightProfile: profile };
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalDownloadBytes = (profile.manifestReceipt.bytes ?? 0) +
+                    (profile.javascriptReceipt.bytes ?? 0) +
+                    (profile.wasmReceipt.bytes ?? 0);
+                const totalDecompressedBytes = profile.wasmReceipt.uncompressedBytes ?? 0;
+                const payload = await preflightStaticRuntimeAssetsInWorker({
+                    runtimeId: 'JANET',
+                    displayName: 'Janet',
+                    baseUrl: urls.baseUrl,
+                    manifestUrl: urls.manifestUrl || '',
+                    profile,
+                    limits: context.limits,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        if (progress.kind === 'asset') {
+                            loadedByAsset.set(progress.progress.assetKey, progress.progress.loadedBytes);
+                            const loadedBytes = [...loadedByAsset.values()].reduce((total, loaded) => total + loaded, 0);
+                            const fraction = totalDownloadBytes > 0 ? loadedBytes / totalDownloadBytes : 0;
+                            context.reportProgress(0.04 + Math.min(1, fraction) * 0.1, `Preflighting Janet asset ${progress.progress.assetKey}`);
+                            return;
+                        }
+                        const { loadedBytes } = progress;
+                        const fraction = totalDecompressedBytes > 0
+                            ? loadedBytes / totalDecompressedBytes
+                            : 0;
+                        context.reportProgress(0.14 + Math.min(1, fraction) * 0.03, 'Decompressing verified Janet wasm');
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Janet;

package/dist/playground/java.d.ts

@@ -1,33 +1,47 @@
 import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
 import { WorkerAssetBridge } from './assetBridge';
 import { type PlaygroundRuntimeAssets } from './assets';
-import type { Sandbox } from './sandbox';
+import type { Sandbox, SandboxProgress } from './sandbox';
 declare class Java implements Sandbox {
     output: any;
     worker?: Worker;
-    buffer: SharedArrayBuffer;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
     pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
     exit: boolean;
     baseUrl: string;
-    activeReject: ((reason: string) => void) | null;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;
     assetBridge: WorkerAssetBridge | null;
-    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>): Promise<void>;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private disposedConfigurationError;
+    private requireOperationIdle;
+    private beginOperation;
+    private isOperationActive;
+    private releaseOperation;
+    private cleanupOperation;
+    private releaseBeforeSession;
+    private bindPreSessionAbort;
+    private bindAbortSignal;
+    private bindOperationTimeout;
+    private resetExplicitStdinState;
+    private finishExplicitStdin;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;
-    run(code: string, prepare: boolean, _log?: boolean, _prog?: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    private cancelOperation;
     kill(): void;
-    terminate(): void;
+    terminate(reason?: unknown): void;
     clear(): Promise<void>;
+    dispose(): Promise<void>;
 }
 export default Java;