wasm-idle 0.7.2 → 1.0.0

package/dist/playground/rustWorkerLimits.d.ts

@@ -0,0 +1,17 @@
+import { type ExecutionLimits } from '@wasm-idle/core';
+export declare const RUST_NON_DEBUG_RESOURCE_REQUIREMENTS: Readonly<{
+    maxWorkers: 1;
+    maxThreads: 4;
+}>;
+export declare const RUST_NON_DEBUG_MAX_ASSET_DELIVERY_BYTES: number;
+export interface RustNonDebugResourceLimits {
+    readonly maxWorkers: number;
+    readonly maxThreads: number;
+    readonly maxAssetDeliveryBytes: number;
+    readonly compilerLimits: Readonly<{
+        maxWorkers: number;
+        maxThreads: number;
+    }>;
+}
+export declare function snapshotRustNonDebugResourceLimits(value: unknown): RustNonDebugResourceLimits;
+export declare function resolveRustNonDebugResourceLimits(limits?: Partial<ExecutionLimits>): RustNonDebugResourceLimits;

package/dist/playground/rustWorkerLimits.js

@@ -0,0 +1,34 @@
+import { RuntimeConfigurationError, resolveExecutionLimits } from '@wasm-idle/core';
+export const RUST_NON_DEBUG_RESOURCE_REQUIREMENTS = Object.freeze({
+    maxWorkers: 1,
+    maxThreads: 4
+});
+// The largest pinned logical target closure is currently 179,123,525 bytes (wasip3).
+export const RUST_NON_DEBUG_MAX_ASSET_DELIVERY_BYTES = 192 * 1024 * 1024;
+export function snapshotRustNonDebugResourceLimits(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new RuntimeConfigurationError('Rust non-debug execution limits must be an object', {
+            phase: 'compile',
+            runtimeId: 'wasm-rust'
+        });
+    }
+    const limits = value;
+    for (const name of ['maxWorkers', 'maxThreads', 'maxAssetBytes']) {
+        if (!Number.isSafeInteger(limits[name]) || limits[name] <= 0) {
+            throw new RuntimeConfigurationError(`Rust non-debug execution limit ${name} must be a positive safe integer`, { phase: 'compile', runtimeId: 'wasm-rust' });
+        }
+    }
+    const maxWorkers = limits.maxWorkers;
+    const maxThreads = limits.maxThreads;
+    const maxAssetDeliveryBytes = Math.min(limits.maxAssetBytes, RUST_NON_DEBUG_MAX_ASSET_DELIVERY_BYTES / 2) * 2;
+    const compilerLimits = Object.freeze({ maxWorkers, maxThreads });
+    return Object.freeze({
+        maxWorkers,
+        maxThreads,
+        maxAssetDeliveryBytes,
+        compilerLimits
+    });
+}
+export function resolveRustNonDebugResourceLimits(limits = {}) {
+    return snapshotRustNonDebugResourceLimits(resolveExecutionLimits(limits));
+}

package/dist/playground/sandbox.d.ts

@@ -1,25 +1,30 @@
-import type { CompilerDiagnostic, DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { CompilerDiagnostic, DebugCommand, DebugDataBreakpoint, DebugDataBreakpointInfo, DebugDataBreakpointInfoArguments, DebugMemory, DebugResolvedDataBreakpoint, DebugSessionEvent, DebugWriteMemoryResult, SandboxExecutionOptions } from './options';
 import type { PlaygroundRuntimeAssets } from './assets';
-import type { Writable } from 'svelte/store';
+import type { ExecutionLimits, SandboxProgress as CoreSandboxProgress } from '@wasm-idle/core';
 export type SandboxRuntimeAssets = string | PlaygroundRuntimeAssets;
-export type SandboxProgress = Writable<number> | {
-    set?: (value: number) => void;
-};
+export type SandboxProgress = CoreSandboxProgress;
 export interface Sandbox {
     constructor: any;
+    readonly defaultExecutionLimits?: Readonly<Partial<ExecutionLimits>>;
     eof: () => void;
     load: (runtimeAssets?: SandboxRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress) => Promise<void>;
     run: (code: string, prepare: boolean, log?: boolean, prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
-    terminate: () => void;
+    terminate: () => void | Promise<void>;
     clear: () => Promise<void>;
-    kill?: () => void;
+    dispose?: () => void | Promise<void>;
+    kill?: () => void | Promise<void>;
     write?: (data: string) => void;
     output?: (data: string) => void;
     ondebug?: (event: DebugSessionEvent) => void;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
-    debugCommand?: (command: DebugCommand) => void;
-    setBreakpoints?: (lines: number[]) => void;
+    debugCommand?: (command: DebugCommand) => void | Promise<void>;
+    debugPause?: () => void | Promise<void>;
+    setBreakpoints?: (lines: number[], sourcePath?: string) => void | Promise<void>;
     debugEvaluate?: (expression: string) => Promise<string>;
+    debugReadMemory?: (memoryReference: string, offset: number, count: number) => Promise<DebugMemory | null>;
+    debugWriteMemory?: (memoryReference: string, offset: number, data: Uint8Array, allowPartial?: boolean) => Promise<DebugWriteMemoryResult | null>;
+    debugDataBreakpointInfo?: (arguments_: DebugDataBreakpointInfoArguments) => Promise<DebugDataBreakpointInfo | null>;
+    debugSetDataBreakpoints?: (breakpoints: DebugDataBreakpoint[]) => Promise<DebugResolvedDataBreakpoint[]>;
     image?: (data: {
         mime: string;
         b64: string;
@@ -27,8 +32,9 @@ export interface Sandbox {
     }) => void;
     elapse?: number;
 }
-export interface BoundSandbox extends Omit<Sandbox, 'load'> {
+export interface BoundSandbox extends Omit<Sandbox, 'load' | 'dispose'> {
     load: (code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress) => Promise<void>;
+    dispose?: () => Promise<void>;
     runtimeAssets: SandboxRuntimeAssets;
 }
 export interface PlaygroundTerminalProps {

package/dist/playground/sharedBuffer.d.ts

@@ -0,0 +1,6 @@
+export type WasmIdleSharedBuffer = ArrayBuffer | SharedArrayBuffer;
+export declare const isSharedArrayBufferAvailable: () => boolean;
+export declare const createWasmIdleSharedBuffer: (byteLength: number) => WasmIdleSharedBuffer;
+export declare const isSharedBufferBacked: (buffer: ArrayBufferLike | undefined | null) => boolean;
+export declare const isSharedBufferBackedView: (view: ArrayBufferView | undefined | null) => boolean;
+export declare const requireSharedArrayBuffer: (feature: string) => void;

package/dist/playground/sharedBuffer.js

@@ -0,0 +1,12 @@
+export const isSharedArrayBufferAvailable = () => typeof globalThis.SharedArrayBuffer === 'function' &&
+    (typeof globalThis.crossOriginIsolated !== 'boolean' || globalThis.crossOriginIsolated);
+export const createWasmIdleSharedBuffer = (byteLength) => isSharedArrayBufferAvailable()
+    ? new SharedArrayBuffer(byteLength)
+    : new ArrayBuffer(byteLength);
+export const isSharedBufferBacked = (buffer) => typeof globalThis.SharedArrayBuffer === 'function' && buffer instanceof SharedArrayBuffer;
+export const isSharedBufferBackedView = (view) => isSharedBufferBacked(view?.buffer);
+export const requireSharedArrayBuffer = (feature) => {
+    if (isSharedArrayBufferAvailable())
+        return;
+    throw new Error(`${feature} requires SharedArrayBuffer. This browser context is not cross-origin isolated; provide stdin before starting the program and avoid interactive controls in this environment.`);
+};

package/dist/playground/sqlite.d.ts

@@ -0,0 +1,38 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Sqlite implements Sandbox {
+    output: any;
+    worker?: Worker;
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    wasmUrl: string;
+    moduleUrl: string;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private requireOperationIdle;
+    private beginOperation;
+    private isOperationActive;
+    private releaseOperation;
+    private cleanupOperation;
+    private releaseBeforeSession;
+    private bindPreSessionAbort;
+    private bindAbortSignal;
+    private bindOperationTimeout;
+    private cancelOperation;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    write(): void;
+    eof(): void;
+    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 Sqlite;