wasm-idle 0.7.2 → 1.0.0

package/dist/playground/prolog.js

@@ -0,0 +1,75 @@
+import { resolvePrologRuntimeAssetConfig } from './assets';
+import { preflightStaticRuntimeAssetsInWorker } from './staticRuntimePreflight';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, snapshotPrologRuntimePreflightProfile } from '@wasm-idle/core';
+export const PROLOG_WORKER_IDLE_TIMEOUT_MS = 60_000;
+class Prolog extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'PROLOG',
+            displayName: 'Prolog',
+            defaultActivePath: 'main.prolog',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(read_line_to_string|read_line_to_codes|get_char|get_code|read\s*\(|read_string)\b/
+            },
+            workerLifetime: {
+                mode: 'persistent',
+                idleTimeoutMs: PROLOG_WORKER_IDLE_TIMEOUT_MS,
+                evictOnMemoryPressure: true
+            },
+            inlineVerifiedWorker: true,
+            runtimePreflightDelivery: 'transfer-owned-worker-cache',
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolvePrologRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotPrologRuntimePreflightProfile(resolved.preflightProfile);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Prolog runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'PROLOG' });
+                }
+                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.wasmReceipt.uncompressedBytes ?? 0) +
+                    (profile.dataReceipt.uncompressedBytes ?? 0);
+                const payload = await preflightStaticRuntimeAssetsInWorker({
+                    runtimeId: 'PROLOG',
+                    displayName: 'Prolog',
+                    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 Prolog asset ${progress.progress.assetKey}`);
+                            return;
+                        }
+                        const { asset, loadedBytes } = progress;
+                        if (!asset)
+                            return;
+                        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 Prolog ${asset}`);
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Prolog;

package/dist/playground/python.d.ts

@@ -1,7 +1,7 @@
 import type { DebugCommand, DebugSessionEvent, 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 Python implements Sandbox {
     ts: number;
     output: any;
@@ -12,11 +12,11 @@ declare class Python implements Sandbox {
         ts?: number;
     }) => void;
     worker?: Worker;
-    buffer: SharedArrayBuffer;
-    debugBuffer: SharedArrayBuffer;
-    watchBuffer: SharedArrayBuffer;
-    watchResultBuffer: SharedArrayBuffer;
-    interruptBuffer: SharedArrayBuffer;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    debugBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    watchBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    watchResultBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    interruptBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
     pendingInput: string[];
     begin: number;
     elapse: number;
@@ -25,20 +25,26 @@ declare class Python implements Sandbox {
     pendingEof: boolean;
     exit: boolean;
     assetBridge: WorkerAssetBridge | null;
-    activeReject: ((reason?: string) => void) | 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 readonly workerSession;
+    private beginOperation;
+    private isOperationActive;
+    private releaseOperation;
+    private cleanupOperation;
+    private releaseBeforeSession;
+    private cancelOperation;
+    private bindAbortSignal;
+    private bindStartupTimeout;
+    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>;
     debugCommand(command: DebugCommand): void;
+    setBreakpoints(lines: number[]): void;
     debugEvaluate(expression: string): Promise<string>;
     kill(): void;
-    terminate(): void;
+    terminate(reason?: unknown): void;
     clear(): Promise<void>;
 }
 export default Python;