wasm-idle 0.7.2 → 1.0.0

package/dist/playground/bashWorkerProtocol.d.ts

@@ -0,0 +1,88 @@
+import { type BashRuntimePreflightPayload, type ExecutionLimits, type RuntimeResourceKind, type WorkspaceLimits } from '@wasm-idle/core';
+export declare const BASH_WORKER_PROTOCOL_VERSION: 1;
+export interface BashSerializedError {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+    readonly code?: string;
+    readonly recoverable?: boolean;
+    readonly profileId?: string;
+    readonly actual?: number;
+    readonly limit?: number;
+    readonly timeoutMs?: number;
+    readonly resource?: RuntimeResourceKind;
+    readonly feature?: string;
+    readonly languageId?: string;
+}
+export type BashWorkerErrorPhase = 'asset' | 'startup' | 'execute' | 'protocol';
+interface BashWorkerEnvelope {
+    readonly protocolVersion: typeof BASH_WORKER_PROTOCOL_VERSION;
+    readonly sessionId: number;
+    readonly requestId: number;
+}
+export interface BashWorkerLoadMessage extends BashWorkerEnvelope {
+    readonly type: 'load';
+    readonly runtimePreflight: BashRuntimePreflightPayload;
+    readonly limits: ExecutionLimits;
+    readonly log?: boolean;
+}
+export interface BashWorkerRunMessage extends BashWorkerEnvelope {
+    readonly type: 'run';
+    readonly code: string;
+    readonly activePath: string;
+    readonly workspaceFiles: ReadonlyArray<Readonly<{
+        path: string;
+        content: string;
+    }>>;
+    readonly programArgs: readonly string[];
+    readonly stdin?: string;
+    readonly limits: ExecutionLimits;
+    readonly workspaceLimits: WorkspaceLimits;
+    readonly log?: boolean;
+}
+export interface BashWorkerStdinMessage extends BashWorkerEnvelope {
+    readonly type: 'stdin';
+    readonly bytes: Uint8Array;
+}
+export interface BashWorkerStdinEofMessage extends BashWorkerEnvelope {
+    readonly type: 'stdin-eof';
+}
+export type BashHostToWorkerMessage = BashWorkerLoadMessage | BashWorkerRunMessage | BashWorkerStdinMessage | BashWorkerStdinEofMessage;
+export interface BashWorkerProgressMessage extends BashWorkerEnvelope {
+    readonly type: 'progress';
+    readonly value: number;
+    readonly stage?: string;
+}
+export interface BashWorkerLoadedMessage extends BashWorkerEnvelope {
+    readonly type: 'loaded';
+}
+export interface BashWorkerStdinReadyMessage extends BashWorkerEnvelope {
+    readonly type: 'stdin-ready';
+}
+export interface BashWorkerExecutionReadyMessage extends BashWorkerEnvelope {
+    readonly type: 'execution-ready';
+    readonly progress: Readonly<{
+        kind: 'ready';
+        state: 'running';
+        reason: 'started';
+        label?: string;
+    }>;
+}
+export interface BashWorkerOutputMessage extends BashWorkerEnvelope {
+    readonly type: 'output';
+    readonly stream: 'stdout' | 'stderr';
+    readonly bytes: Uint8Array;
+}
+export interface BashWorkerResultMessage extends BashWorkerEnvelope {
+    readonly type: 'result';
+    readonly result: boolean | string;
+}
+export interface BashWorkerErrorMessage extends BashWorkerEnvelope {
+    readonly type: 'error';
+    readonly phase: BashWorkerErrorPhase;
+    readonly error: BashSerializedError;
+}
+export type BashWorkerToHostMessage = BashWorkerProgressMessage | BashWorkerLoadedMessage | BashWorkerStdinReadyMessage | BashWorkerExecutionReadyMessage | BashWorkerOutputMessage | BashWorkerResultMessage | BashWorkerErrorMessage;
+export declare function isBashHostToWorkerMessage(value: unknown): value is BashHostToWorkerMessage;
+export declare function isBashWorkerToHostMessage(value: unknown): value is BashWorkerToHostMessage;
+export {};

package/dist/playground/bashWorkerProtocol.js

@@ -0,0 +1,135 @@
+import { requireBashRuntimePreflightPayload } from '@wasm-idle/core';
+export const BASH_WORKER_PROTOCOL_VERSION = 1;
+const EXECUTION_LIMIT_KEYS = [
+    'assetTimeoutMs',
+    'startupTimeoutMs',
+    'compileTimeoutMs',
+    'runTimeoutMs',
+    'maxOutputBytes',
+    'maxDiagnostics',
+    'maxWorkspaceBytes',
+    'maxAssetBytes',
+    'maxWasmMemoryBytes',
+    'maxWorkers',
+    'maxThreads'
+];
+const WORKSPACE_LIMIT_KEYS = [
+    'maxFiles',
+    'maxFileBytes',
+    'maxTotalBytes',
+    'maxPathBytes'
+];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isUint8Array(value) {
+    return (ArrayBuffer.isView(value) && Object.prototype.toString.call(value) === '[object Uint8Array]');
+}
+function isIdentifier(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function hasEnvelope(value) {
+    return (value.protocolVersion === BASH_WORKER_PROTOCOL_VERSION &&
+        isIdentifier(value.sessionId) &&
+        isIdentifier(value.requestId));
+}
+function hasResolvedExecutionLimits(value) {
+    if (!isRecord(value))
+        return false;
+    return EXECUTION_LIMIT_KEYS.every((key) => Number.isSafeInteger(value[key]) && value[key] > 0);
+}
+function hasResolvedWorkspaceLimits(value) {
+    if (!isRecord(value) || typeof value.caseSensitive !== 'boolean')
+        return false;
+    return WORKSPACE_LIMIT_KEYS.every((key) => Number.isSafeInteger(value[key]) && value[key] >= 0);
+}
+function hasRuntimePreflight(value) {
+    try {
+        requireBashRuntimePreflightPayload(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasWorkspaceFiles(value) {
+    return (Array.isArray(value) &&
+        value.every((file) => isRecord(file) && typeof file.path === 'string' && typeof file.content === 'string'));
+}
+function hasStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+export function isBashHostToWorkerMessage(value) {
+    if (!isRecord(value) || !hasEnvelope(value))
+        return false;
+    switch (value.type) {
+        case 'load':
+            return (hasRuntimePreflight(value.runtimePreflight) &&
+                hasResolvedExecutionLimits(value.limits) &&
+                (value.log === undefined || typeof value.log === 'boolean'));
+        case 'run':
+            return (typeof value.code === 'string' &&
+                typeof value.activePath === 'string' &&
+                hasWorkspaceFiles(value.workspaceFiles) &&
+                hasStringArray(value.programArgs) &&
+                (value.stdin === undefined || typeof value.stdin === 'string') &&
+                hasResolvedExecutionLimits(value.limits) &&
+                hasResolvedWorkspaceLimits(value.workspaceLimits) &&
+                (value.log === undefined || typeof value.log === 'boolean'));
+        case 'stdin':
+            return isUint8Array(value.bytes);
+        case 'stdin-eof':
+            return true;
+        default:
+            return false;
+    }
+}
+function hasSerializedError(value) {
+    return (isRecord(value) &&
+        typeof value.name === 'string' &&
+        typeof value.message === 'string' &&
+        (value.stack === undefined || typeof value.stack === 'string') &&
+        (value.code === undefined || typeof value.code === 'string') &&
+        (value.recoverable === undefined || typeof value.recoverable === 'boolean') &&
+        (value.profileId === undefined || typeof value.profileId === 'string') &&
+        (value.actual === undefined || Number.isSafeInteger(value.actual)) &&
+        (value.limit === undefined || Number.isSafeInteger(value.limit)) &&
+        (value.timeoutMs === undefined || Number.isSafeInteger(value.timeoutMs)) &&
+        (value.resource === undefined ||
+            value.resource === 'wasm-memory' ||
+            value.resource === 'nested-workers' ||
+            value.resource === 'threads') &&
+        (value.feature === undefined || typeof value.feature === 'string') &&
+        (value.languageId === undefined || typeof value.languageId === 'string'));
+}
+export function isBashWorkerToHostMessage(value) {
+    if (!isRecord(value) || !hasEnvelope(value))
+        return false;
+    switch (value.type) {
+        case 'progress':
+            return (Number.isFinite(value.value) &&
+                (value.stage === undefined || typeof value.stage === 'string'));
+        case 'loaded':
+        case 'stdin-ready':
+            return true;
+        case 'execution-ready':
+            return (isRecord(value.progress) &&
+                value.progress.kind === 'ready' &&
+                value.progress.state === 'running' &&
+                value.progress.reason === 'started' &&
+                (value.progress.label === undefined || typeof value.progress.label === 'string'));
+        case 'output':
+            return ((value.stream === 'stdout' || value.stream === 'stderr') &&
+                isUint8Array(value.bytes));
+        case 'result':
+            return typeof value.result === 'boolean' || typeof value.result === 'string';
+        case 'error':
+            return ((value.phase === 'asset' ||
+                value.phase === 'startup' ||
+                value.phase === 'execute' ||
+                value.phase === 'protocol') &&
+                hasSerializedError(value.error));
+        default:
+            return false;
+    }
+}

package/dist/playground/bqn.d.ts

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

package/dist/playground/bqn.js

@@ -0,0 +1,57 @@
+import { resolveBqnRuntimeAssetConfig } from './assets';
+import { preflightStaticRuntimeAssetsInWorker } from './staticRuntimePreflight';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError } from '@wasm-idle/core';
+class Bqn extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'BQN',
+            displayName: 'BQN',
+            defaultActivePath: 'main.bqn',
+            moduleWorker: true,
+            inlineVerifiedWorker: true,
+            stdin: { mode: 'streaming', sourceHintPattern: /•GetLine|stdin/iu },
+            runtimePreflightDelivery: 'transfer-owned',
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveBqnRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = resolved.preflightProfile;
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('BQN runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'BQN' });
+                }
+                return resolved;
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalDownloadBytes = (profile.manifestReceipt?.bytes ?? 0) +
+                    (profile.moduleReceipt?.bytes ?? 0) +
+                    (profile.wasmReceipt?.bytes ?? 0);
+                const payload = await preflightStaticRuntimeAssetsInWorker({
+                    runtimeId: 'BQN',
+                    displayName: 'BQN',
+                    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.11, `Preflighting BQN asset ${progress.progress.assetKey}`);
+                            return;
+                        }
+                        const { loadedBytes, totalBytes } = progress;
+                        const fraction = totalBytes > 0 ? loadedBytes / totalBytes : 0;
+                        context.reportProgress(0.15 + Math.min(1, fraction) * 0.02, 'Decompressing verified BQN Wasm');
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Bqn;

package/dist/playground/bqnPreflight.d.ts

@@ -0,0 +1,26 @@
+import type { BqnRuntimePreflightProfile } from './assets';
+import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+export declare const BQN_PREFLIGHT_PROTOCOL: "wasm-idle-bqn-preflight";
+export declare const BQN_PREFLIGHT_PROTOCOL_VERSION: 1;
+export declare const BQN_PREFLIGHT_RUNTIME_ID: "BQN";
+export interface BqnRuntimePreflightRequest {
+    readonly baseUrl: string;
+    readonly manifestUrl: string;
+    readonly profile: BqnRuntimePreflightProfile;
+    readonly limits?: Partial<ExecutionLimits>;
+    readonly signal?: AbortSignal;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;
+    readonly reportDecompressionProgress?: (loadedBytes: number, totalBytes: number) => void;
+}
+export interface BqnRuntimePreflightPayload {
+    readonly protocol: typeof BQN_PREFLIGHT_PROTOCOL;
+    readonly protocolVersion: typeof BQN_PREFLIGHT_PROTOCOL_VERSION;
+    readonly profileId: string;
+    readonly sourceRevision: string;
+    readonly manifestFingerprint: string;
+    readonly manifestBytes: Uint8Array;
+    readonly moduleBytes: Uint8Array;
+    readonly wasmBytes: Uint8Array;
+}
+export declare function preflightBqnRuntimeAssets(request: BqnRuntimePreflightRequest): Promise<BqnRuntimePreflightPayload>;