wasm-idle 0.7.2 → 1.0.0

package/dist/playground/rubyAssets.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedRubyRuntimeAssetConfig } from './assets';
+import { type ExecutionLimits, type RubyRuntimePreflightPayload, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+export interface RubyRuntimePreflightOptions {
+    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 type RubyRuntimePreflightDeliveryState = 'available' | 'consumed' | 'retired';
+export interface RubyRuntimeOwnedPreflightDelivery {
+    readonly payload: RubyRuntimePreflightPayload;
+    readonly state: RubyRuntimePreflightDeliveryState;
+    consume(): readonly [ArrayBuffer, ArrayBuffer, ArrayBuffer];
+    retire(): void;
+}
+/**
+ * Adopts a freshly preflighted Ruby payload for exactly one Worker load dispatch.
+ * The caller relinquishes every payload byte view after consume(), regardless of
+ * whether postMessage succeeds; a consumed or retired delivery cannot be reused.
+ */
+export declare function createRubyRuntimeOwnedPreflightDelivery(value: unknown): RubyRuntimeOwnedPreflightDelivery;
+export declare function preflightVerifiedRubyRuntimeAssets(config: ResolvedRubyRuntimeAssetConfig, options?: RubyRuntimePreflightOptions): Promise<RubyRuntimePreflightPayload>;

package/dist/playground/rubyAssets.js

@@ -0,0 +1,68 @@
+import { preflightRubyRuntimeAssets, requireRubyRuntimePreflightPayload } from '@wasm-idle/core';
+function isPlainFrozenRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || !Object.isFrozen(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function requireOwnedWholeBuffer(value, label) {
+    if (value.byteLength <= 0 ||
+        !(value.buffer instanceof ArrayBuffer) ||
+        value.byteOffset !== 0 ||
+        value.byteLength !== value.buffer.byteLength) {
+        throw new TypeError(`Ruby runtime ${label} must exclusively own one nonempty whole buffer`);
+    }
+    return value.buffer;
+}
+/**
+ * Adopts a freshly preflighted Ruby payload for exactly one Worker load dispatch.
+ * The caller relinquishes every payload byte view after consume(), regardless of
+ * whether postMessage succeeds; a consumed or retired delivery cannot be reused.
+ */
+export function createRubyRuntimeOwnedPreflightDelivery(value) {
+    if (!isPlainFrozenRecord(value)) {
+        throw new TypeError('Ruby runtime preflight delivery requires one frozen plain payload');
+    }
+    const payload = requireRubyRuntimePreflightPayload(value);
+    const transferables = [
+        requireOwnedWholeBuffer(payload.manifestBytes, 'manifest bytes'),
+        requireOwnedWholeBuffer(payload.moduleJavaScriptBytes, 'module JavaScript bytes'),
+        requireOwnedWholeBuffer(payload.wasmBytes, 'Wasm bytes')
+    ];
+    if (new Set(transferables).size !== transferables.length) {
+        throw new TypeError('Ruby runtime preflight byte buffers must have unique ownership');
+    }
+    let state = 'available';
+    return Object.freeze({
+        payload,
+        get state() {
+            return state;
+        },
+        consume() {
+            if (state !== 'available') {
+                throw new TypeError('Ruby runtime preflight delivery is no longer available');
+            }
+            state = 'consumed';
+            return transferables;
+        },
+        retire() {
+            if (state === 'available')
+                state = 'retired';
+        }
+    });
+}
+export async function preflightVerifiedRubyRuntimeAssets(config, options = {}) {
+    return await preflightRubyRuntimeAssets({
+        baseUrl: config.baseUrl,
+        manifestUrl: config.manifestUrl,
+        moduleUrl: config.moduleUrl,
+        wasmUrl: config.wasmUrl,
+        profile: config.preflightProfile,
+        limits: options.limits,
+        signal: options.signal,
+        fetch: options.fetch,
+        reportProgress: options.reportProgress,
+        reportDecompressionProgress: options.reportDecompressionProgress
+    });
+}

package/dist/playground/rubyTestPreflight.d.ts

@@ -0,0 +1,2 @@
+import { type RubyRuntimePreflightPayload } from '@wasm-idle/core';
+export declare function createRubyRuntimeTestPreflightPayload(): RubyRuntimePreflightPayload;

package/dist/playground/rubyTestPreflight.js

@@ -0,0 +1,18 @@
+import { RUBY_PREFLIGHT_PROTOCOL, RUBY_PREFLIGHT_PROTOCOL_VERSION, RUBY_RUNTIME_PROFILE } from '@wasm-idle/core';
+export function createRubyRuntimeTestPreflightPayload() {
+    return Object.freeze({
+        protocol: RUBY_PREFLIGHT_PROTOCOL,
+        protocolVersion: RUBY_PREFLIGHT_PROTOCOL_VERSION,
+        profileId: RUBY_RUNTIME_PROFILE.profileId,
+        artifactRevision: RUBY_RUNTIME_PROFILE.artifactRevision,
+        rubyVersion: RUBY_RUNTIME_PROFILE.rubyVersion,
+        rubyRevision: RUBY_RUNTIME_PROFILE.rubyRevision,
+        rubyWasmVersion: RUBY_RUNTIME_PROFILE.rubyWasmVersion,
+        rubyWasmRevision: RUBY_RUNTIME_PROFILE.rubyWasmRevision,
+        wasiSdkVersion: RUBY_RUNTIME_PROFILE.wasiSdkVersion,
+        manifestFingerprint: RUBY_RUNTIME_PROFILE.manifestFingerprint,
+        manifestBytes: Uint8Array.of(1),
+        moduleJavaScriptBytes: Uint8Array.of(2),
+        wasmBytes: Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0)
+    });
+}

package/dist/playground/runtimeModule.d.ts

@@ -0,0 +1 @@
+export declare function importRuntimeModule<T>(moduleUrl: string): Promise<T>;

package/dist/playground/runtimeModule.js

@@ -0,0 +1,5 @@
+export async function importRuntimeModule(moduleUrl) {
+    if (!moduleUrl)
+        throw new Error('Runtime module URL is not configured.');
+    return (await import(/* @vite-ignore */ moduleUrl));
+}

package/dist/playground/rust.d.ts

@@ -1,32 +1,63 @@
-import { type PlaygroundRuntimeAssets } from './assets';
-import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
-import type { Sandbox } from './sandbox';
+import { type PlaygroundRuntimeAssets, type RuntimeAssetIntegrityEntry } from './assets';
+import { type DebugCommand, type DebugDataBreakpoint, type DebugDataBreakpointInfoArguments, type DebugSessionEvent, type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
 declare class Rust implements Sandbox {
     output: any;
+    ondebug?: (event: DebugSessionEvent) => void;
     worker?: Worker;
-    buffer: SharedArrayBuffer;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    debugBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
     pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
     exit: boolean;
     compilerUrl: string;
+    debugModuleUrl: string;
     assetPath: string;
-    activeReject: ((reason: string) => void) | null;
+    debugRuntimeBaseUrl: string;
+    debugManifestUrl: string;
+    debugManifestReceipt?: Readonly<RuntimeAssetIntegrityEntry>;
+    executableGraphFingerprint: string;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;
-    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 readonly workerSession;
+    private readonly workerExecutableGraphs;
+    private loadGeneration;
+    private loadController;
+    private pendingLoadWorker;
+    private pendingLoadGraph;
+    private pendingLoadReject;
+    private runActive;
+    private lldbSession?;
+    private debugMode;
+    private activeDebugPhaseTimeout?;
+    private readonly lldbBreakpoints;
+    private lldbEditorSourcePath;
+    private disposeWorkerExecutableGraph;
+    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>;
-    kill(): void;
-    terminate(): void;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    debugCommand(command: DebugCommand): Promise<void> | undefined;
+    debugPause(): Promise<void> | undefined;
+    setBreakpoints(lines: number[], sourcePath?: string): Promise<void> | undefined;
+    debugEvaluate(expression: string): Promise<string>;
+    debugVariables(variablesReference: number, start?: number, count?: number): Promise<import("@wasm-idle/core").DebugVariable[]>;
+    debugScopes(frameId: number): Promise<import("@wasm-idle/core").DebugScope[]>;
+    debugFrameScopes(frameId: number): Promise<import("@wasm-idle/core").DebugScope[]>;
+    debugFrameName(frameId: number): Promise<string | null>;
+    debugReadMemory(memoryReference: string, offset: number, count: number): Promise<import("@wasm-idle/core").DebugMemory | null>;
+    debugWriteMemory(memoryReference: string, offset: number, data: Uint8Array, allowPartial?: boolean): Promise<{
+        offset?: number;
+        bytesWritten: number;
+    } | null>;
+    debugDataBreakpointInfo(arguments_: DebugDataBreakpointInfoArguments): Promise<import("@wasm-idle/core").DebugDataBreakpointInfo | null>;
+    debugSetDataBreakpoints(breakpoints: DebugDataBreakpoint[]): Promise<import("@wasm-idle/core").DebugResolvedDataBreakpoint[]>;
+    kill(): Promise<void>;
+    terminate(): Promise<void>;
     clear(): Promise<void>;
 }
 export default Rust;