wasm-idle 0.7.2 → 1.0.0

package/dist/playground/stdinBuffer.d.ts

@@ -1,7 +1,9 @@
-export declare const flushQueuedStdin: (queue: string[], buffer: SharedArrayBuffer | Int32Array) => boolean;
-export declare const readBufferedStdin: (buffer: SharedArrayBuffer | Int32Array) => string | null;
-export declare const bufferedSequence: (buffer: SharedArrayBuffer | Int32Array) => number;
-export declare const waitForBufferedSequenceChange: (buffer: SharedArrayBuffer | Int32Array, sequence: number, timeoutMs?: number) => Promise<string | null>;
-export declare const flushBufferedEof: (buffer: SharedArrayBuffer | Int32Array) => void;
-export declare const waitForBufferedStdin: (buffer: Int32Array, requestInput: () => void) => string | null;
-export declare const resetBufferedStdin: (buffer: SharedArrayBuffer | Int32Array) => void;
+type StdinBuffer = ArrayBufferLike | Int32Array;
+export declare const flushQueuedStdin: (queue: string[], buffer: StdinBuffer) => boolean;
+export declare const readBufferedStdin: (buffer: StdinBuffer) => string | null;
+export declare const bufferedSequence: (buffer: StdinBuffer) => number;
+export declare const waitForBufferedSequenceChange: (buffer: StdinBuffer, sequence: number, timeoutMs?: number) => Promise<string | null>;
+export declare const flushBufferedEof: (buffer: StdinBuffer) => void;
+export declare const waitForBufferedStdin: (buffer: Int32Array | null | undefined, requestInput: () => void) => string | null;
+export declare const resetBufferedStdin: (buffer: StdinBuffer) => void;
+export {};

package/dist/playground/stdinBuffer.js

@@ -1,3 +1,4 @@
+import { isSharedBufferBackedView } from './sharedBuffer';
 const SEQUENCE_INDEX = 0;
 const LENGTH_INDEX = 1;
 const HEADER_BYTES = Int32Array.BYTES_PER_ELEMENT * 2;
@@ -7,26 +8,14 @@ const decoder = new TextDecoder();
 const controlViewOf = (buffer) => buffer instanceof Int32Array ? buffer : new Int32Array(buffer);
 const payloadViewOf = (control) => new Uint8Array(control.buffer, control.byteOffset + HEADER_BYTES, control.byteLength - HEADER_BYTES);
 const splitChunk = (input, maxBytes) => {
-    const encoded = encoder.encode(input);
-    if (encoded.length <= maxBytes) {
-        return { chunk: input, bytes: encoded, rest: '' };
+    const bytes = new Uint8Array(maxBytes);
+    const { read, written } = encoder.encodeInto(input, bytes);
+    if (input.length > 0 && read === 0) {
+        throw new RangeError('Stdin buffer payload cannot fit the next UTF-8 character');
     }
-    let left = 0;
-    let right = input.length;
-    while (left < right) {
-        const middle = Math.ceil((left + right) / 2);
-        if (encoder.encode(input.slice(0, middle)).length <= maxBytes) {
-            left = middle;
-        }
-        else {
-            right = middle - 1;
-        }
-    }
-    const chunk = input.slice(0, left);
     return {
-        chunk,
-        bytes: encoder.encode(chunk),
-        rest: input.slice(left)
+        bytes: bytes.subarray(0, written),
+        rest: input.slice(read)
     };
 };
 export const flushQueuedStdin = (queue, buffer) => {
@@ -82,6 +71,8 @@ export const flushBufferedEof = (buffer) => {
     Atomics.notify(control, SEQUENCE_INDEX);
 };
 export const waitForBufferedStdin = (buffer, requestInput) => {
+    if (!buffer || !isSharedBufferBackedView(buffer))
+        return null;
     const sequence = Atomics.load(buffer, SEQUENCE_INDEX);
     requestInput();
     while (true) {

package/dist/playground/swift.d.ts

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

package/dist/playground/swift.js

@@ -0,0 +1,17 @@
+import { resolveSwiftRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+class Swift extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            displayName: 'Swift',
+            languageId: 'SWIFT',
+            defaultActivePath: 'main.swift',
+            stdin: {
+                mode: 'prebuffered',
+                sourceHintPattern: /\b(?:readLine|FileHandle\.standardInput|stdin)\b/
+            },
+            resolveRuntimeAssets: resolveSwiftRuntimeAssetConfig
+        });
+    }
+}
+export default Swift;

package/dist/playground/tcl.d.ts

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

package/dist/playground/tcl.js

@@ -0,0 +1,62 @@
+import { resolveTclRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, preflightTclRuntimeAssets, snapshotTclRuntimePreflightProfile } from '@wasm-idle/core';
+class Tcl extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'TCL',
+            displayName: 'Tcl',
+            defaultActivePath: 'main.tcl',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(gets|read)\s+(stdin|file\d*)\b|\bstdin\b/
+            },
+            inlineVerifiedWorker: true,
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveTclRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotTclRuntimePreflightProfile(resolved.preflightProfile);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Tcl runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'TCL' });
+                }
+                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.requireJsReceipt.bytes ?? 0) +
+                    (profile.customDataReceipt.bytes ?? 0) +
+                    (profile.libraryDataReceipt.bytes ?? 0) +
+                    (profile.glueReceipt.bytes ?? 0) +
+                    (profile.wasmReceipt.bytes ?? 0);
+                const totalDecompressedBytes = (profile.libraryDataReceipt.uncompressedBytes ?? 0) +
+                    (profile.wasmReceipt.uncompressedBytes ?? 0);
+                return await preflightTclRuntimeAssets({
+                    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 Tcl 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 Tcl ${asset}`);
+                    }
+                });
+            }
+        });
+    }
+}
+export default Tcl;

package/dist/playground/teavmConfig.d.ts

@@ -1,3 +1,3 @@
 export declare const normalizeTeaVmBaseUrl: (baseUrl: string) => string;
-export declare const resolveTeaVmBaseUrl: (pathPrefix?: string, currentUrl?: string) => string;
+export declare const resolveTeaVmBaseUrl: (pathPrefix?: string, currentUrl?: string, configuredBaseUrl?: string) => string;
 export declare const resolveTeaVmAssetUrl: (baseUrl: string, assetPath: string) => string;

package/dist/playground/teavmConfig.js

@@ -4,8 +4,8 @@ const normalizePathPrefix = (pathPrefix) => {
         return '';
     return pathPrefix.endsWith('/') ? pathPrefix.slice(0, -1) : pathPrefix;
 };
-export const resolveTeaVmBaseUrl = (pathPrefix = '', currentUrl = '') => {
-    const configuredBaseUrl = (import.meta.env.PUBLIC_TEAVM_BASE_URL || '').trim();
+export const resolveTeaVmBaseUrl = (pathPrefix = '', currentUrl = '', configuredBaseUrl = '') => {
+    configuredBaseUrl = configuredBaseUrl.trim();
     const baseUrl = configuredBaseUrl
         ? normalizeTeaVmBaseUrl(configuredBaseUrl)
         : `${normalizePathPrefix(pathPrefix) || ''}/teavm/`;

package/dist/playground/tinygo.d.ts

@@ -1,6 +1,7 @@
-import { type PlaygroundRuntimeAssets, type TinyGoRuntimeAssetLoader, type TinyGoRuntimeAssetPackReference } from './assets';
-import { type SandboxExecutionOptions, type TinyGoTarget } from './options';
-import type { Sandbox } from './sandbox';
+import { type PlaygroundRuntimeAssets, type RuntimeAssetIntegrityEntry, type TinyGoRuntimeAssetLoader } from './assets';
+import { type LoadedTinyGoExecutableGraph } from './tinygoExecutableGraph';
+import type { CompilerDiagnostic, SandboxExecutionOptions, TinyGoTarget } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
 type TinyGoRuntimeHooks = {
     boot(): Promise<void>;
     plan(): Promise<unknown>;
@@ -18,37 +19,47 @@ type TinyGoRuntimeHooks = {
     setBuildRequestOverrides?(overrides: {
         target?: TinyGoTarget;
     } | null): void;
+    setMaxAssetBytes?(maxAssetBytes: number): void;
+    setMaxWasmMemoryBytes?(maxWasmMemoryBytes: number): void;
     setWorkspaceFiles(files: Record<string, string> | null): void;
     dispose?(): void;
 };
+type TinyGoUpstreamRuntimeProfile = {
+    profileId: string;
+    protocolVersion: number;
+    manifestPath: string;
+    manifestFingerprint: string;
+    manifestReceipt: RuntimeAssetIntegrityEntry;
+    assetReceipts: Readonly<Record<string, RuntimeAssetIntegrityEntry>>;
+};
 declare class TinyGo implements Sandbox {
     output: any;
     worker?: Worker;
-    buffer: SharedArrayBuffer;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
     pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
     exit: boolean;
     moduleUrl: string;
-    hostCompileUrl: string;
-    hostCompileUrls: string[];
+    executableGraphFingerprint: string;
     rustRuntimeBaseUrl: string;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     assetLoader: TinyGoRuntimeAssetLoader | undefined;
-    assetPacks: TinyGoRuntimeAssetPackReference[] | undefined;
+    runtimeProfile: TinyGoUpstreamRuntimeProfile | undefined;
+    executableGraph: LoadedTinyGoExecutableGraph | null;
     runtime: TinyGoRuntimeHooks | null;
+    runtimeToken: symbol | null;
     runtimePromise: Promise<TinyGoRuntimeHooks> | null;
+    private runtimePromiseToken;
     loadPromise: Promise<void> | null;
     compiledArtifact: Uint8Array | null;
     compiledArtifactExecutionError: string;
     compiledCacheKey: string;
-    activeReject: ((reason: string) => void) | null;
     waitingForInput: boolean;
     pendingEof: boolean;
     lastActivityLog: string;
-    runtimeProgress: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number> | undefined;
+    runtimeProgress: SandboxProgress | undefined;
     runtimeProgressStart: number;
     runtimeProgressEnd: number;
     runtimeProgressValue: number;
@@ -56,23 +67,42 @@ declare class TinyGo implements Sandbox {
         loaded: number;
         total: number;
     }>;
-    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 runtimeProgressOwner;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private disposedConfigurationError;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    private beginOperation;
+    private completeOperation;
+    private isOperationActive;
+    private assertOperation;
+    private snapshotExecutionLimits;
+    private executeOperation;
+    private emitOutput;
+    private emitCompilerDiagnostic;
+    private clearPendingStdin;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;
     private ensureWorker;
+    private detachRuntime;
+    private disposeRuntimeHooks;
     private disposeRuntime;
+    private reportRuntimeProgress;
+    private requireRuntimeAssetLimitSetter;
     private ensureRuntime;
     private emitActivityLog;
     private extractCompileFailure;
     private compileArtifact;
-    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>;
+    private resetOwnedBuffers;
+    private cancelOperation;
     kill(): void;
-    terminate(): void;
+    terminate(reason?: unknown): void;
     clear(): Promise<void>;
+    dispose(): Promise<void>;
 }
 export default TinyGo;