wasm-idle 0.7.2 → 1.0.0

package/dist/playground/options.d.ts

@@ -1,9 +1,5 @@
-export type DebugCommand = 'continue' | 'stepInto' | 'nextLine' | 'stepOut';
-export type DebugPauseReason = 'breakpoint' | 'entry' | 'step' | 'nextLine' | 'stepOut';
-export interface DebugVariable {
-    name: string;
-    value: string;
-}
+import type { DebugSourceBreakpoints, ExecutionLimits, WorkspaceLimits } from '@wasm-idle/core';
+export type { DebugArrayElementKind, DebugCommand, DebugDataBreakpoint, DebugDataBreakpointAccessType, DebugDataBreakpointInfo, DebugDataBreakpointInfoArguments, DebugFrame, DebugMemory, DebugPauseReason, DebugResolvedBreakpoint, DebugResolvedDataBreakpoint, DebugSessionCapabilities, DebugSessionEvent, DebugScope, DebugSourceBreakpoints, DebugStructFieldMetadata, DebugVariable, DebugVariableKind, DebugVariableMetadata, DebugWriteMemoryResult } from '@wasm-idle/core';
 export type CompilerDiagnosticSeverity = 'error' | 'warning' | 'other';
 export interface CompilerDiagnostic {
     fileName?: string | null;
@@ -14,50 +10,32 @@ export interface CompilerDiagnostic {
     message: string;
 }
 export type RustTargetTriple = 'wasm32-wasip1' | 'wasm32-wasip2' | 'wasm32-wasip3';
+export type BrowserDebugMode = 'none' | 'trace' | 'lldb';
 export type GoTarget = 'wasip1/wasm' | 'wasip2/wasm' | 'wasip3/wasm' | 'js/wasm';
 export type TinyGoTarget = 'wasm' | 'wasip1' | 'wasip2' | 'wasip3';
 export type OcamlBackend = 'js' | 'wasm';
 export type OcamlWasmBinaryenMode = 'fast' | 'full';
-export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
-export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
-export interface DebugStructFieldMetadata {
-    name: string;
-    kind: DebugArrayElementKind;
-    offset: number;
-}
-export interface DebugVariableMetadata {
-    slot: number;
-    name: string;
-    kind: DebugVariableKind;
-    fromLine: number;
-    toLine: number;
-    elementKind?: DebugArrayElementKind;
-    length?: number;
-    dimensions?: number[];
-    structFields?: DebugStructFieldMetadata[];
-    structSize?: number;
-}
-export interface DebugFrame {
-    functionName: string;
-    line: number;
+export type ZigTargetTriple = 'wasm64-wasi';
+export interface SandboxWorkspaceFile {
+    path: string;
+    content: string;
 }
-export type DebugSessionEvent = {
-    type: 'pause';
-    line: number;
-    reason: DebugPauseReason;
-    locals: DebugVariable[];
-    callStack: DebugFrame[];
-} | {
-    type: 'resume';
-    command: DebugCommand;
-} | {
-    type: 'stop';
-};
 export interface SandboxExecutionOptions {
+    debugMode?: BrowserDebugMode;
+    /** @deprecated Use debugMode. true maps to trace unless the caller explicitly selects lldb. */
     debug?: boolean;
+    /** Keep the final run alive until the host explicitly stops or disposes it. */
+    interactive?: boolean;
     breakpoints?: number[];
+    sourceBreakpoints?: DebugSourceBreakpoints[];
     pauseOnEntry?: boolean;
     stdin?: string;
+    signal?: AbortSignal;
+    limits?: Partial<ExecutionLimits>;
+    workspaceLimits?: Partial<WorkspaceLimits>;
+    activePath?: string;
+    debugPath?: string;
+    workspaceFiles?: SandboxWorkspaceFile[];
     compileArgs?: string[];
     programArgs?: string[];
     cppVersion?: string;
@@ -67,6 +45,7 @@ export interface SandboxExecutionOptions {
     tinygoTarget?: TinyGoTarget;
     ocamlBackend?: OcamlBackend;
     ocamlWasmBinaryenMode?: OcamlWasmBinaryenMode;
+    zigTargetTriple?: ZigTargetTriple;
 }
 export interface ResolvedSandboxExecutionArgs {
     compileArgs: string[];

package/dist/playground/options.js

@@ -1,8 +1,9 @@
 function cloneArgs(value) {
     return Array.isArray(value) ? [...value] : [];
 }
+const compileArgLanguages = new Set(['C', 'CPP', 'OBJC']);
 export function resolveSandboxExecutionArgs(language, args = [], options = {}) {
-    if (language === 'C' || language === 'CPP') {
+    if (compileArgLanguages.has(language)) {
         return {
             compileArgs: cloneArgs(options.compileArgs ?? args),
             programArgs: cloneArgs(options.programArgs)

package/dist/playground/pascal.d.ts

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

package/dist/playground/pascal.js

@@ -0,0 +1,60 @@
+import { resolvePascalRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, preflightPascalRuntimeAssets, snapshotPascalRuntimePreflightProfile } from '@wasm-idle/core';
+class Pascal extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'PASCAL',
+            displayName: 'Pascal',
+            defaultActivePath: 'main.pas',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            stdin: { mode: 'streaming', sourceHintPattern: /\bReadLn\s*\(/i },
+            inlineVerifiedWorker: true,
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolvePascalRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotPascalRuntimePreflightProfile(resolved.preflightProfile);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Pascal runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'PASCAL' });
+                }
+                return { ...resolved, preflightProfile: profile };
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const resolved = urls;
+                const profile = resolved.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalDownloadBytes = [
+                    profile.manifestReceipt.bytes,
+                    profile.compilerJavaScriptReceipt.bytes,
+                    profile.rtlJavaScriptReceipt.bytes,
+                    profile.systemPascalReceipt.bytes
+                ].reduce((total, bytes) => total + (bytes ?? 0), 0);
+                const totalDecompressedBytes = profile.compilerJavaScriptReceipt.uncompressedBytes ?? 0;
+                const payload = await preflightPascalRuntimeAssets({
+                    baseUrl: resolved.baseUrl,
+                    manifestUrl: resolved.manifestUrl,
+                    compilerJavaScriptUrl: resolved.compilerJavaScriptUrl,
+                    rtlJavaScriptUrl: resolved.rtlJavaScriptUrl,
+                    systemPascalUrl: resolved.systemPascalUrl,
+                    profile,
+                    limits: context.limits,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        loadedByAsset.set(progress.assetKey, 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 Pascal asset ${progress.assetKey}`);
+                    },
+                    reportDecompressionProgress(loadedBytes) {
+                        const fraction = totalDecompressedBytes > 0 ? loadedBytes / totalDecompressedBytes : 0;
+                        context.reportProgress(0.14 + Math.min(1, fraction) * 0.03, 'Decompressing verified Pascal compiler');
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Pascal;

package/dist/playground/perl.d.ts

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

package/dist/playground/perl.js

@@ -0,0 +1,61 @@
+import { resolvePerlRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, preflightPerlRuntimeAssets, snapshotPerlRuntimePreflightProfile } from '@wasm-idle/core';
+class Perl extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'PERL',
+            displayName: 'Perl',
+            defaultActivePath: 'main.pl',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /<\s*STDIN\s*>|\bSTDIN\b|\breadline\b|<\s*>/
+            },
+            inlineVerifiedWorker: true,
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolvePerlRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotPerlRuntimePreflightProfile(resolved.preflightProfile);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('WebPerl runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'PERL' });
+                }
+                return { ...resolved, preflightProfile: profile };
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const decompressedByAsset = new Map();
+                const totalDownloadBytes = (profile.manifestReceipt.bytes ?? 0) +
+                    (profile.javascriptReceipt.bytes ?? 0) +
+                    (profile.wasmReceipt.bytes ?? 0) +
+                    (profile.dataReceipt.bytes ?? 0);
+                const totalDecompressedBytes = (profile.javascriptReceipt.uncompressedBytes ?? 0) +
+                    (profile.wasmReceipt.uncompressedBytes ?? 0) +
+                    (profile.dataReceipt.uncompressedBytes ?? 0);
+                return await preflightPerlRuntimeAssets({
+                    baseUrl: urls.baseUrl,
+                    manifestUrl: urls.manifestUrl || '',
+                    profile,
+                    limits: context.limits,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        loadedByAsset.set(progress.assetKey, 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 WebPerl asset ${progress.assetKey}`);
+                    },
+                    reportDecompressionProgress(asset, loadedBytes) {
+                        decompressedByAsset.set(asset, loadedBytes);
+                        const decompressedBytes = [...decompressedByAsset.values()].reduce((total, loaded) => total + loaded, 0);
+                        const fraction = totalDecompressedBytes > 0
+                            ? decompressedBytes / totalDecompressedBytes
+                            : 0;
+                        context.reportProgress(0.14 + Math.min(1, fraction) * 0.03, `Decompressing verified WebPerl ${asset}`);
+                    }
+                });
+            }
+        });
+    }
+}
+export default Perl;

package/dist/playground/php.d.ts

@@ -0,0 +1,44 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Php implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    moduleUrl: string;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private beginOperation;
+    private isOperationActive;
+    private releaseOperation;
+    private cleanupOperation;
+    private releaseBeforeSession;
+    private bindPreSessionAbort;
+    private bindAbortSignal;
+    private bindOperationTimeout;
+    private resetSharedStdinBuffer;
+    private prepareRunStdin;
+    private finishRunStdin;
+    private cancelOperation;
+    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>;
+    kill(): void;
+    terminate(reason?: unknown): void;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export default Php;