wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/bash.js

@@ -0,0 +1,338 @@
+import { BASH_WORKER_PROTOCOL_VERSION, isBashHostToWorkerMessage } from '../bashWorkerProtocol';
+import BashWorkerRuntime from './bashRuntime';
+class BashBridgeProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProtocolError';
+    }
+}
+const workerSelf = globalThis;
+const runtime = new BashWorkerRuntime();
+let activeOperation = null;
+let activeRun = null;
+let loadedSessionId = null;
+function postMessage(message, transfer) {
+    if (transfer) {
+        workerSelf.postMessage(message, transfer);
+        return;
+    }
+    workerSelf.postMessage(message);
+}
+function copyStringProperty(value, key) {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+        return undefined;
+    }
+    try {
+        const property = value[key];
+        return typeof property === 'string' ? property : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function copyBooleanProperty(value, key) {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+        return undefined;
+    }
+    try {
+        const property = value[key];
+        return typeof property === 'boolean' ? property : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function copySafeIntegerProperty(value, key) {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+        return undefined;
+    }
+    try {
+        const property = value[key];
+        return Number.isSafeInteger(property) && property >= 0
+            ? property
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function safelyStringify(value) {
+    try {
+        return String(value);
+    }
+    catch {
+        return 'Unknown Bash worker error';
+    }
+}
+function serializeError(error) {
+    const name = copyStringProperty(error, 'name') || 'Error';
+    const message = copyStringProperty(error, 'message') ||
+        (typeof error === 'string' ? error : safelyStringify(error));
+    const stack = copyStringProperty(error, 'stack');
+    const code = copyStringProperty(error, 'code');
+    const recoverable = copyBooleanProperty(error, 'recoverable');
+    const profileId = copyStringProperty(error, 'profileId');
+    const actual = copySafeIntegerProperty(error, 'actual');
+    const limit = copySafeIntegerProperty(error, 'limit');
+    const timeoutMs = copySafeIntegerProperty(error, 'timeoutMs');
+    const resource = copyStringProperty(error, 'resource');
+    const feature = copyStringProperty(error, 'feature');
+    const languageId = copyStringProperty(error, 'languageId');
+    return {
+        name,
+        message,
+        ...(stack ? { stack } : {}),
+        ...(code ? { code } : {}),
+        ...(recoverable === undefined ? {} : { recoverable }),
+        ...(profileId ? { profileId } : {}),
+        ...(actual === undefined ? {} : { actual }),
+        ...(limit === undefined ? {} : { limit }),
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(resource === 'wasm-memory' || resource === 'nested-workers' || resource === 'threads'
+            ? { resource }
+            : {}),
+        ...(feature ? { feature } : {}),
+        ...(languageId ? { languageId } : {})
+    };
+}
+function errorPhase(error, fallback) {
+    if (error instanceof BashBridgeProtocolError)
+        return 'protocol';
+    if ((typeof error !== 'object' && typeof error !== 'function') || error === null) {
+        return fallback;
+    }
+    try {
+        const phase = error.phase;
+        if (phase === 'asset' || phase === 'startup' || phase === 'execute')
+            return phase;
+    }
+    catch {
+        // An untrusted error getter must not prevent clone-safe reporting.
+    }
+    return fallback;
+}
+function postError(identity, error, fallbackPhase) {
+    postMessage({
+        protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+        type: 'error',
+        sessionId: identity.sessionId,
+        requestId: identity.requestId,
+        phase: errorPhase(error, fallbackPhase),
+        error: serializeError(error)
+    });
+}
+function requestIdentity(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    try {
+        const { sessionId, requestId } = value;
+        if (!Number.isSafeInteger(sessionId) ||
+            sessionId <= 0 ||
+            !Number.isSafeInteger(requestId) ||
+            requestId <= 0) {
+            return null;
+        }
+        return { sessionId: sessionId, requestId: requestId };
+    }
+    catch {
+        return null;
+    }
+}
+function assertIdle(message) {
+    if (!activeOperation)
+        return;
+    throw new BashBridgeProtocolError(`Cannot ${message.type} Bash while ${activeOperation.type} request ${activeOperation.requestId} is active`);
+}
+function ownsOperation(message) {
+    return (activeOperation?.type === message.type &&
+        activeOperation.sessionId === message.sessionId &&
+        activeOperation.requestId === message.requestId);
+}
+async function handleLoad(message) {
+    assertIdle(message);
+    activeOperation = {
+        type: 'load',
+        sessionId: message.sessionId,
+        requestId: message.requestId
+    };
+    try {
+        await runtime.loadVerified(message.runtimePreflight, message.log ?? false, { limits: { ...message.limits } }, {
+            set(value, stage) {
+                if (!ownsOperation(message))
+                    return;
+                postMessage({
+                    protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+                    type: 'progress',
+                    sessionId: message.sessionId,
+                    requestId: message.requestId,
+                    value,
+                    ...(stage === undefined ? {} : { stage })
+                });
+            }
+        });
+        if (!ownsOperation(message))
+            return;
+        loadedSessionId = message.sessionId;
+        postMessage({
+            protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+            type: 'loaded',
+            sessionId: message.sessionId,
+            requestId: message.requestId
+        });
+    }
+    finally {
+        if (ownsOperation(message))
+            activeOperation = null;
+    }
+}
+async function handleRun(message) {
+    assertIdle(message);
+    if (loadedSessionId !== message.sessionId) {
+        throw new BashBridgeProtocolError(`Bash worker session ${message.sessionId} has not loaded a runtime`);
+    }
+    const run = {
+        executionReady: false,
+        sessionId: message.sessionId,
+        requestId: message.requestId,
+        stdinDecoder: new TextDecoder()
+    };
+    activeOperation = {
+        type: 'run',
+        sessionId: message.sessionId,
+        requestId: message.requestId
+    };
+    activeRun = run;
+    try {
+        const runPromise = runtime.run(message.code, false, message.log ?? false, {
+            report(progress) {
+                if (progress.kind !== 'ready' ||
+                    progress.state !== 'running' ||
+                    progress.reason !== 'started' ||
+                    run.executionReady ||
+                    activeRun !== run ||
+                    !ownsOperation(message)) {
+                    return;
+                }
+                run.executionReady = true;
+                postMessage({
+                    protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+                    type: 'execution-ready',
+                    sessionId: message.sessionId,
+                    requestId: message.requestId,
+                    progress: {
+                        kind: 'ready',
+                        state: 'running',
+                        reason: 'started',
+                        ...(progress.label ? { label: progress.label } : {})
+                    }
+                });
+                if (message.stdin === undefined &&
+                    activeRun === run &&
+                    ownsOperation(message)) {
+                    postMessage({
+                        protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+                        type: 'stdin-ready',
+                        sessionId: message.sessionId,
+                        requestId: message.requestId
+                    });
+                }
+            }
+        }, [...message.programArgs], {
+            activePath: message.activePath,
+            workspaceFiles: message.workspaceFiles.map(({ path, content }) => ({
+                path,
+                content
+            })),
+            programArgs: [...message.programArgs],
+            ...(message.stdin === undefined ? {} : { stdin: message.stdin }),
+            limits: { ...message.limits },
+            workspaceLimits: { ...message.workspaceLimits }
+        });
+        const result = await runPromise;
+        if (!ownsOperation(message))
+            return;
+        postMessage({
+            protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+            type: 'result',
+            sessionId: message.sessionId,
+            requestId: message.requestId,
+            result
+        });
+    }
+    finally {
+        if (activeRun === run)
+            activeRun = null;
+        if (ownsOperation(message))
+            activeOperation = null;
+    }
+}
+function handleStdin(message) {
+    const run = activeRun;
+    if (!run || run.sessionId !== message.sessionId || run.requestId !== message.requestId) {
+        return;
+    }
+    const input = run.stdinDecoder.decode(message.bytes, { stream: true });
+    if (input)
+        runtime.write(input);
+}
+function handleStdinEof(message) {
+    const run = activeRun;
+    if (!run || run.sessionId !== message.sessionId || run.requestId !== message.requestId) {
+        return;
+    }
+    const finalInput = run.stdinDecoder.decode();
+    if (finalInput)
+        runtime.write(finalInput);
+    runtime.eof();
+}
+runtime.outputBytes = (stream, output) => {
+    const run = activeRun;
+    if (!run)
+        return;
+    const bytes = Uint8Array.from(output);
+    postMessage({
+        protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+        type: 'output',
+        sessionId: run.sessionId,
+        requestId: run.requestId,
+        stream,
+        bytes
+    }, [bytes.buffer]);
+};
+async function dispatch(message) {
+    switch (message.type) {
+        case 'load':
+            await handleLoad(message);
+            return;
+        case 'run':
+            await handleRun(message);
+            return;
+        case 'stdin':
+            handleStdin(message);
+            return;
+        case 'stdin-eof':
+            handleStdinEof(message);
+    }
+}
+workerSelf.onmessage = async (event) => {
+    const identity = requestIdentity(event.data);
+    if (!isBashHostToWorkerMessage(event.data)) {
+        if (identity) {
+            postError(identity, new BashBridgeProtocolError('Invalid Bash worker protocol message'), 'protocol');
+        }
+        return;
+    }
+    try {
+        await dispatch(event.data);
+    }
+    catch (error) {
+        postError(event.data, error, event.data.type === 'load'
+            ? 'startup'
+            : event.data.type === 'run' ||
+                event.data.type === 'stdin' ||
+                event.data.type === 'stdin-eof'
+                ? 'execute'
+                : 'protocol');
+    }
+};
+export {};

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

@@ -0,0 +1,6 @@
+export interface BashNestedBootstrapSourceOptions {
+    sdkModuleUrl: string;
+    sentinelUrl: string;
+    realmUrl: string;
+}
+export declare function createBashNestedBootstrapSource(options: BashNestedBootstrapSourceOptions): string;

package/dist/playground/worker/bashNestedBootstrap.js

@@ -0,0 +1,59 @@
+function requireHierarchicalHttpUrl(value, label) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch (error) {
+        throw new TypeError(`Bash ${label} URL is invalid`, { cause: error });
+    }
+    if ((url.protocol !== 'https:' && url.protocol !== 'http:') || url.username || url.password) {
+        throw new TypeError(`Bash ${label} URL must be a credential-free hierarchical HTTP URL`);
+    }
+    return url;
+}
+export function createBashNestedBootstrapSource(options) {
+    const realmUrl = requireHierarchicalHttpUrl(options.realmUrl, 'realm');
+    const sentinelUrl = requireHierarchicalHttpUrl(options.sentinelUrl, 'sentinel');
+    if (sentinelUrl.origin !== realmUrl.origin || sentinelUrl.hash) {
+        throw new TypeError('Bash SDK sentinel URL must be same-origin and must not contain a hash');
+    }
+    let sdkModuleUrl;
+    try {
+        sdkModuleUrl = new URL(options.sdkModuleUrl);
+    }
+    catch (error) {
+        throw new TypeError('Bash verified SDK Blob URL is invalid', { cause: error });
+    }
+    if (sdkModuleUrl.protocol !== 'blob:' || sdkModuleUrl.origin !== realmUrl.origin) {
+        throw new TypeError('Bash SDK module URL must be a same-origin verified Blob URL');
+    }
+    const sdkModuleLiteral = JSON.stringify(sdkModuleUrl.href);
+    const sentinelLiteral = JSON.stringify(sentinelUrl.href);
+    return `const verifiedSdkUrl = ${sdkModuleLiteral};
+const sdkSentinelUrl = ${sentinelLiteral};
+let threadPoolWorker;
+const pendingMessages = [];
+globalThis.onerror = console.error;
+globalThis.onmessage = async (event) => {
+  const data = event.data;
+  if (data?.type === 'init') {
+    if (threadPoolWorker) {
+      throw new Error('Bash nested worker has already been initialized');
+    }
+    const { memory, module, id } = data;
+    const { init, ThreadPoolWorker } = await import(verifiedSdkUrl);
+    await init({ module, memory, sdkUrl: sdkSentinelUrl });
+    threadPoolWorker = new ThreadPoolWorker(id);
+    for (const pending of pendingMessages.splice(0, pendingMessages.length)) {
+      await threadPoolWorker.handle(pending);
+    }
+    return;
+  }
+  if (threadPoolWorker) {
+    await threadPoolWorker.handle(data);
+  } else {
+    pendingMessages.push(data);
+  }
+};
+`;
+}

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

@@ -0,0 +1,89 @@
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from '../options';
+import type { Sandbox, SandboxProgress, SandboxRuntimeAssets } from '../sandbox';
+import { type BashRuntimePreflightPayload } from '@wasm-idle/core';
+interface WasixInstance {
+    stdin?: WritableStream<Uint8Array>;
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    wait(): Promise<{
+        ok: boolean;
+        code: number;
+    }>;
+    free(): void;
+}
+interface WasmerCommand {
+    run(options: Record<string, unknown>): Promise<WasixInstance>;
+    free(): void;
+}
+interface WasmerPackage {
+    entrypoint?: WasmerCommand;
+    free(): void;
+}
+interface WasmerRuntime {
+    free?(): void;
+}
+interface WasmerSdk {
+    init(options: {
+        module: Uint8Array | WebAssembly.Module;
+        sdkUrl: string;
+        workerUrl: string;
+    }): Promise<unknown>;
+    Runtime: new (options: {
+        registry: null;
+    }) => WasmerRuntime;
+    Wasmer: {
+        fromFile(bytes: Uint8Array, runtime: WasmerRuntime): Promise<WasmerPackage>;
+    };
+}
+export interface BashWorkerRuntimeDependencies {
+    readonly importVerifiedSdkModule?: (url: string) => Promise<WasmerSdk>;
+}
+declare class BashWorkerRuntime implements Sandbox {
+    output?: (data: string) => void;
+    outputBytes?: (stream: 'stdout' | 'stderr', data: Uint8Array) => void;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    webcUrl: string;
+    runtimePackage: WasmerPackage | null;
+    instance: WasixInstance | null;
+    stdinWriter: WritableStreamDefaultWriter | null;
+    outputController: AbortController | null;
+    pendingInput: string[];
+    pendingEof: boolean;
+    activeLoadReject: ((reason: unknown) => void) | null;
+    activeLoadCleanup: (() => void) | null;
+    private loadGeneration;
+    private sdkModule;
+    private sdkRuntime;
+    private sdkBlobUrl;
+    private nestedWorkerBlobUrl;
+    activeReject: ((reason: unknown) => void) | null;
+    activeRunCleanup: (() => void) | null;
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    private activeOperation;
+    private readonly importVerifiedSdkModule;
+    constructor(dependencies?: BashWorkerRuntimeDependencies);
+    private beginOperation;
+    private isOperationActive;
+    private requireOperationActive;
+    private snapshotExecutionLimits;
+    private releaseOperation;
+    private cleanupOperation;
+    private abortOperationSignal;
+    private bindOperationTimeout;
+    private releaseBeforeSession;
+    private bindPreSessionAbort;
+    load(_runtimeAssets?: SandboxRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, _progress?: SandboxProgress): Promise<void>;
+    loadVerified(runtimePreflight: BashRuntimePreflightPayload, _log?: boolean, options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    private disposeRunHandles;
+    run(code: string, prepare: boolean, _log?: boolean, progress?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    kill(): void;
+    terminate(reason?: unknown): void;
+    clear(): Promise<void>;
+}
+export default BashWorkerRuntime;