wasm-idle 0.7.2 → 1.0.0

package/dist/playground/elixirAssets.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeAssetIntegrityEntry } from '@wasm-idle/core';
+export declare const ELIXIR_RUNTIME_ASSET_NAMES: readonly ["bundle.avm", "AtomVM.mjs", "AtomVM.wasm"];
+export type ElixirRuntimeAssetName = (typeof ELIXIR_RUNTIME_ASSET_NAMES)[number];
+export type ElixirRuntimeAssetReceipt = Readonly<Required<Pick<RuntimeAssetIntegrityEntry, 'bytes' | 'sha256' | 'uncompressedBytes' | 'uncompressedSha256'>>>;
+export type ElixirRuntimeAssetReceipts = Readonly<Record<ElixirRuntimeAssetName, ElixirRuntimeAssetReceipt>>;
+export declare function snapshotElixirRuntimeAssetReceipts(value: ElixirRuntimeAssetReceipts | undefined): ElixirRuntimeAssetReceipts;

package/dist/playground/elixirAssets.js

@@ -0,0 +1,33 @@
+export const ELIXIR_RUNTIME_ASSET_NAMES = ['bundle.avm', 'AtomVM.mjs', 'AtomVM.wasm'];
+export function snapshotElixirRuntimeAssetReceipts(value) {
+    const receivedAssets = Object.keys(value || {}).sort();
+    const expectedAssets = [...ELIXIR_RUNTIME_ASSET_NAMES].sort();
+    if (receivedAssets.length !== expectedAssets.length ||
+        receivedAssets.some((asset, index) => asset !== expectedAssets[index])) {
+        throw new TypeError('Elixir runtime requires exactly three asset receipts');
+    }
+    const receipts = Object.fromEntries(ELIXIR_RUNTIME_ASSET_NAMES.map((asset) => {
+        const receipt = value?.[asset];
+        if (!receipt ||
+            !Number.isSafeInteger(receipt.bytes) ||
+            receipt.bytes <= 0 ||
+            typeof receipt.sha256 !== 'string' ||
+            !/^[a-f0-9]{64}$/u.test(receipt.sha256) ||
+            !Number.isSafeInteger(receipt.uncompressedBytes) ||
+            receipt.uncompressedBytes <= 0 ||
+            typeof receipt.uncompressedSha256 !== 'string' ||
+            !/^[a-f0-9]{64}$/u.test(receipt.uncompressedSha256)) {
+            throw new TypeError(`Elixir runtime asset receipt is invalid for ${asset}`);
+        }
+        return [
+            asset,
+            Object.freeze({
+                bytes: receipt.bytes,
+                sha256: receipt.sha256,
+                uncompressedBytes: receipt.uncompressedBytes,
+                uncompressedSha256: receipt.uncompressedSha256
+            })
+        ];
+    }));
+    return Object.freeze(receipts);
+}

package/dist/playground/executionObservation.d.ts

@@ -0,0 +1,22 @@
+import type { ProgressLike } from '@wasm-idle/core';
+export interface ExecutionObservation {
+    id: number;
+    language: string;
+    status: 'idle' | 'preparing' | 'running' | 'waiting-input' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'timed-out';
+    /** The legacy runner only confirms zero on success; failed/unfinished runs have no known exit code. */
+    exitCode: number | null;
+    startedAt: number | null;
+    endedAt: number | null;
+    stage: string;
+    error?: string;
+    events: Array<{
+        at: number;
+        kind: string;
+        stage: string;
+    }>;
+}
+export declare function createExecutionObserver(): {
+    snapshot: () => ExecutionObservation;
+    start(id: number, language: string, progress: ProgressLike): ProgressLike;
+    finish(id: number, status: "completed" | "failed" | "cancelled" | "timed-out", error?: unknown): void;
+};

package/dist/playground/executionObservation.js

@@ -0,0 +1,65 @@
+export function createExecutionObserver() {
+    let current = {
+        id: 0,
+        language: '',
+        status: 'idle',
+        exitCode: null,
+        startedAt: null,
+        endedAt: null,
+        stage: '',
+        events: []
+    };
+    return {
+        snapshot: () => ({
+            ...current,
+            events: current.events.map((event) => ({ ...event }))
+        }),
+        start(id, language, progress) {
+            current = {
+                id,
+                language,
+                status: 'preparing',
+                exitCode: null,
+                startedAt: Date.now(),
+                endedAt: null,
+                stage: 'Preparing execution',
+                events: []
+            };
+            const record = (kind, stage) => {
+                if (current.id !== id || current.endedAt !== null)
+                    return;
+                current.stage = stage;
+                current.events.push({ at: Date.now(), kind, stage });
+                if (current.events.length > 128)
+                    current.events.shift();
+            };
+            return {
+                set(value, stage) {
+                    if (stage)
+                        record('legacy', stage);
+                    progress.set?.(value, stage);
+                },
+                report(event) {
+                    if (current.id === id && current.endedAt === null) {
+                        if (event.kind === 'activity')
+                            record(event.phase, event.label);
+                        if (event.kind === 'ready') {
+                            current.status = event.state;
+                            record(event.reason, event.label ?? event.state);
+                        }
+                    }
+                    progress.report?.(event);
+                }
+            };
+        },
+        finish(id, status, error) {
+            if (current.id !== id || current.endedAt !== null)
+                return;
+            current.status = status;
+            current.exitCode = status === 'completed' ? 0 : null;
+            current.endedAt = Date.now();
+            if (error !== undefined)
+                current.error = String(error).slice(0, 2048);
+        }
+    };
+}

package/dist/playground/forth.d.ts

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

package/dist/playground/forth.js

@@ -0,0 +1,53 @@
+import { resolveForthRuntimeAssetConfig } from './assets';
+import { preflightStaticRuntimeAssetsInWorker } from './staticRuntimePreflight';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError } from '@wasm-idle/core';
+class Forth extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'FORTH',
+            displayName: 'Forth',
+            defaultActivePath: 'main.fth',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(?:KEY|ACCEPT|REFILL)\b/i
+            },
+            inlineVerifiedWorker: true,
+            runtimePreflightDelivery: 'transfer-owned',
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveForthRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = resolved.preflightProfile;
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Forth runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'FORTH' });
+                }
+                return resolved;
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalBytes = (profile.manifestReceipt?.bytes ?? 0) + (profile.runtimeReceipt?.bytes ?? 0);
+                const payload = await preflightStaticRuntimeAssetsInWorker({
+                    runtimeId: 'FORTH',
+                    displayName: 'Forth',
+                    baseUrl: urls.baseUrl,
+                    manifestUrl: urls.manifestUrl || '',
+                    profile,
+                    limits: context.limits,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        if (progress.kind !== 'asset')
+                            return;
+                        loadedByAsset.set(progress.progress.assetKey, progress.progress.loadedBytes);
+                        const loadedBytes = [...loadedByAsset.values()].reduce((total, loaded) => total + loaded, 0);
+                        const fraction = totalBytes > 0 ? loadedBytes / totalBytes : 0;
+                        context.reportProgress(0.04 + Math.min(1, fraction) * 0.13, `Preflighting Forth asset ${progress.progress.assetKey}`);
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Forth;

package/dist/playground/forthPreflight.d.ts

@@ -0,0 +1,24 @@
+import type { ForthRuntimePreflightProfile } from './assets';
+import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+export declare const FORTH_PREFLIGHT_PROTOCOL: "wasm-idle-forth-preflight";
+export declare const FORTH_PREFLIGHT_PROTOCOL_VERSION: 1;
+export declare const FORTH_PREFLIGHT_RUNTIME_ID: "FORTH";
+export interface ForthRuntimePreflightRequest {
+    readonly baseUrl: string;
+    readonly manifestUrl: string;
+    readonly profile: ForthRuntimePreflightProfile;
+    readonly limits?: Partial<ExecutionLimits>;
+    readonly signal?: AbortSignal;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;
+}
+export interface ForthRuntimePreflightPayload {
+    readonly protocol: typeof FORTH_PREFLIGHT_PROTOCOL;
+    readonly protocolVersion: typeof FORTH_PREFLIGHT_PROTOCOL_VERSION;
+    readonly profileId: string;
+    readonly implementationVersion: string;
+    readonly manifestFingerprint: string;
+    readonly manifestBytes: Uint8Array;
+    readonly runtimeBytes: Uint8Array;
+}
+export declare function preflightForthRuntimeAssets(request: ForthRuntimePreflightRequest): Promise<ForthRuntimePreflightPayload>;

package/dist/playground/forthPreflight.js

@@ -0,0 +1,198 @@
+import { RuntimeConfigurationError, preflightRuntimeAssets } from '@wasm-idle/core';
+export const FORTH_PREFLIGHT_PROTOCOL = 'wasm-idle-forth-preflight';
+export const FORTH_PREFLIGHT_PROTOCOL_VERSION = 1;
+export const FORTH_PREFLIGHT_RUNTIME_ID = 'FORTH';
+export async function preflightForthRuntimeAssets(request) {
+    if (!request || typeof request !== 'object') {
+        throw new RuntimeConfigurationError('Forth runtime preflight request is required', {
+            phase: 'asset',
+            runtimeId: FORTH_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('Forth runtime asset URLs are invalid', {
+            cause: error,
+            phase: 'asset',
+            runtimeId: FORTH_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    if ((baseUrl.protocol !== 'https:' && baseUrl.protocol !== 'http:') ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('Forth runtime base must be a credential-free HTTP(S) directory URL without a query or fragment', { phase: 'asset', runtimeId: FORTH_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('Forth runtime manifest must be an HTTP(S) asset beneath the configured runtime base', { phase: 'asset', runtimeId: FORTH_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('Forth runtime manifest path must be a normalized file beneath the runtime base', { phase: 'asset', runtimeId: FORTH_PREFLIGHT_RUNTIME_ID });
+    }
+    const profile = request.profile;
+    if (!profile ||
+        typeof profile !== 'object' ||
+        typeof profile.profileId !== 'string' ||
+        !/^waforth-[A-Za-z0-9._-]+$/u.test(profile.profileId) ||
+        typeof profile.implementationVersion !== 'string' ||
+        !/^[A-Za-z0-9._-]+$/u.test(profile.implementationVersion) ||
+        profile.profileId !== `waforth-${profile.implementationVersion}` ||
+        typeof profile.manifestFingerprint !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(profile.manifestFingerprint)) {
+        throw new RuntimeConfigurationError('Forth runtime preflight profile is invalid', {
+            phase: 'asset',
+            runtimeId: FORTH_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    for (const [label, receipt] of [
+        ['manifest', profile.manifestReceipt],
+        ['runtime', profile.runtimeReceipt]
+    ]) {
+        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(`Forth runtime ${label} preflight receipt is invalid`, {
+                phase: 'asset',
+                profileId: profile.profileId,
+                runtimeId: FORTH_PREFLIGHT_RUNTIME_ID
+            });
+        }
+    }
+    if (manifestPath === 'waforth.js') {
+        throw new RuntimeConfigurationError('Forth runtime manifest and executable asset paths must be distinct', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: FORTH_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const manifestReceipt = profile.manifestReceipt;
+    const runtimeReceipt = profile.runtimeReceipt;
+    const expectedManifestQuery = `?v=${profile.manifestFingerprint}`;
+    if (manifestUrl.search && manifestUrl.search !== expectedManifestQuery) {
+        throw new RuntimeConfigurationError('Forth runtime manifest query must be the pinned manifest fingerprint cache-buster', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: FORTH_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    const manifestRequestUrl = new URL(manifestUrl);
+    if (!manifestRequestUrl.search) {
+        manifestRequestUrl.searchParams.set('v', profile.manifestFingerprint);
+    }
+    const runtimeRequestUrl = new URL('waforth.js', baseUrl);
+    runtimeRequestUrl.searchParams.set('v', runtimeReceipt.sha256);
+    const registry = {
+        schemaVersion: 2,
+        manifestId: 'wasm-idle/forth-preflight',
+        revision: profile.manifestFingerprint,
+        runtimes: [
+            {
+                runtimeId: FORTH_PREFLIGHT_RUNTIME_ID,
+                identity: {
+                    languageId: 'FORTH',
+                    implementationId: 'waforth',
+                    implementationVersion: profile.implementationVersion,
+                    profile: {
+                        profileId: profile.profileId,
+                        manifestSchemaVersion: 2,
+                        manifestSha256: manifestReceipt.sha256,
+                        protocolVersion: FORTH_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'],
+                assetRoot: '.',
+                assets: [
+                    {
+                        key: 'manifest',
+                        path: manifestPath,
+                        compressedSha256: manifestReceipt.sha256,
+                        uncompressedSha256: manifestReceipt.sha256,
+                        compressedBytes: manifestReceipt.bytes,
+                        uncompressedBytes: manifestReceipt.bytes,
+                        mediaType: 'application/json',
+                        encoding: 'identity'
+                    },
+                    {
+                        key: 'runtime',
+                        path: 'waforth.js',
+                        compressedSha256: runtimeReceipt.sha256,
+                        uncompressedSha256: runtimeReceipt.sha256,
+                        compressedBytes: runtimeReceipt.bytes,
+                        uncompressedBytes: runtimeReceipt.bytes,
+                        mediaType: 'application/javascript',
+                        encoding: 'identity'
+                    }
+                ],
+                contracts: {
+                    routeId: 'forth',
+                    runtimeAssetKey: 'forth',
+                    documentationId: 'FORTH',
+                    syncTarget: 'sync:wasm-forth',
+                    browserTestId: 'browser:forth'
+                }
+            }
+        ]
+    };
+    const preflight = await preflightRuntimeAssets({
+        manifest: registry,
+        runtimeId: FORTH_PREFLIGHT_RUNTIME_ID,
+        rootUrl: baseUrl,
+        assetUrls: {
+            manifest: manifestRequestUrl,
+            runtime: runtimeRequestUrl
+        },
+        fetch: request.fetch,
+        signal: request.signal,
+        limits: request.limits,
+        maxConcurrentDownloads: 2,
+        reportProgress: request.reportProgress
+    });
+    const manifestAsset = preflight.assets.manifest;
+    const runtimeAsset = preflight.assets.runtime;
+    if (!manifestAsset || !runtimeAsset) {
+        throw new RuntimeConfigurationError('Forth runtime preflight returned an incomplete asset set', {
+            phase: 'asset',
+            profileId: profile.profileId,
+            runtimeId: FORTH_PREFLIGHT_RUNTIME_ID
+        });
+    }
+    return Object.freeze({
+        protocol: FORTH_PREFLIGHT_PROTOCOL,
+        protocolVersion: FORTH_PREFLIGHT_PROTOCOL_VERSION,
+        profileId: profile.profileId,
+        implementationVersion: profile.implementationVersion,
+        manifestFingerprint: profile.manifestFingerprint,
+        manifestBytes: Uint8Array.from(manifestAsset.bytes),
+        runtimeBytes: Uint8Array.from(runtimeAsset.bytes)
+    });
+}

package/dist/playground/fortran.d.ts

@@ -0,0 +1,47 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Fortran implements Sandbox {
+    language: string;
+    output?: (data: string) => void;
+    worker?: Worker;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    log: boolean;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    exit: boolean;
+    assetBridge: WorkerAssetBridge | null;
+    activeFortranAssetsKey: string;
+    private activeOperation;
+    private preserveOperationOnWorkerDispose;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private disposedConfigurationError;
+    private requireOperationIdle;
+    private beginOperation;
+    private isOperationActive;
+    private releaseOperation;
+    private cleanupOperation;
+    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?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    private cancelOperation;
+    kill(): void;
+    terminate(reason?: unknown): void;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export default Fortran;