wasm-idle 0.7.2 → 1.0.0

package/dist/index.d.ts

@@ -1,13 +1,8 @@
-import Terminal from './terminal';
-export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, createDebugSessionController, MonacoDebugView, attachMonacoDebugActions, selectInlineDebugLocals } from './debug';
-export { getEditorLanguageServer, getCppLanguageServer, getPythonLanguageServer, resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './lsp';
 import playground, { createPlaygroundBinding } from './playground';
-export default Terminal;
+export default playground;
 export { createPlaygroundBinding, playground };
-export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './terminal';
-export type { CompilerDiagnostic } from './playground/options';
-export type { DebugSessionController, DebugSessionControllerOptions, DebugWatchValue, MonacoDebugActionsOptions } from './debug';
+export { isSharedArrayBufferAvailable, requireSharedArrayBuffer } from './playground/sharedBuffer';
+export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, TerminalControl } from '@wasm-idle/core';
+export type { CompilerDiagnostic, SandboxExecutionOptions } from './playground/options';
 export type { PlaygroundRuntimeAssets, RuntimeAssetConfig, RuntimeAssetLoadRequest, RuntimeAssetLoader, RuntimeAssetLoaderResult } from './playground/assets';
 export type { BoundSandbox, PlaygroundBinding, PlaygroundTerminalProps, SandboxProgress, SandboxRuntimeAssets } from './playground/sandbox';
-export type { DebugLanguageAdapter } from './debug';
-export type { EditorLanguageServerHandle, EditorLanguageServerRuntimeOptions } from './lsp';

package/dist/index.js

@@ -1,6 +1,4 @@
-import Terminal from './terminal';
-export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, createDebugSessionController, MonacoDebugView, attachMonacoDebugActions, selectInlineDebugLocals } from './debug';
-export { getEditorLanguageServer, getCppLanguageServer, getPythonLanguageServer, resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './lsp';
 import playground, { createPlaygroundBinding } from './playground';
-export default Terminal;
+export default playground;
 export { createPlaygroundBinding, playground };
+export { isSharedArrayBufferAvailable, requireSharedArrayBuffer } from './playground/sharedBuffer';

package/dist/playground/applicationAssets.d.ts

@@ -0,0 +1,4 @@
+import type { PlaygroundRuntimeAssets } from './assets';
+export declare function normalizeApplicationAssetRootUrl(rootUrl: string): string;
+export declare function createApplicationAssetResolver(rootUrl: string): (assetPath: string, version?: string) => string;
+export declare function createApplicationRuntimeAssets(rootUrl: string): PlaygroundRuntimeAssets;

package/dist/playground/applicationAssets.js

@@ -0,0 +1,277 @@
+import { STATIC_RUNTIME_MODULE_VERSION } from './staticRuntimeModuleVersion';
+import { WASM_AWK_RUNTIME_BUNDLE } from './wasmAwkVersion';
+import { WASM_BASH_RUNTIME_PROFILE } from './wasmBashVersion';
+import { WASM_BQN_ASSET_VERSION, WASM_BQN_RUNNER_RECEIPT } from './wasmBqnVersion';
+import { WASM_CLOJURESCRIPT_ASSET_VERSION, WASM_CLOJURESCRIPT_RUNNER_RECEIPT } from './wasmClojureScriptVersion';
+import { WASM_D_INTEGRITY_VERSION, WASM_D_OUTER_ASSET_RECEIPTS } from './wasmDIntegrity';
+import { WASM_DOTNET_ASSET_VERSION } from './wasmDotnetVersion';
+import { WASM_ELIXIR_ASSET_RECEIPTS, WASM_ELIXIR_ASSET_VERSION } from './wasmElixirVersion';
+import { WASM_FORTH_ASSET_VERSION, WASM_FORTH_RUNNER_RECEIPT } from './wasmForthVersion';
+import { WASM_FORTRAN_EXECUTION_ASSET_RECEIPTS, WASM_FORTRAN_EXECUTION_ASSET_VERSION } from './wasmFortranExecutionAssets';
+import { WASM_FORTRAN_ASSET_VERSION } from './wasmFortranVersion';
+import { WASM_GLEAM_ASSET_VERSION, WASM_GLEAM_RUNNER_RECEIPT } from './wasmGleamVersion';
+import { WASM_GO_ASSET_VERSION } from './wasmGoVersion';
+import { WASM_HASKELL_ASSET_VERSION } from './wasmHaskellVersion';
+import { WASM_J_ASSET_VERSION, WASM_J_RUNNER_RECEIPT } from './wasmJVersion';
+import { WASM_JANET_RUNTIME_BUNDLE } from './wasmJanetVersion';
+import { WASM_JULIA_RUNTIME_BUNDLE } from './wasmJuliaVersion';
+import { WASM_LISP_ASSET_VERSION } from './wasmLispVersion';
+import { WASM_LUA_ASSET_VERSION } from './wasmLuaVersion';
+import { WASM_NIM_RUNTIME_BUNDLE } from './wasmNimVersion';
+import { WASM_OBJECTIVEC_ASSET_RECEIPTS, WASM_OBJECTIVEC_ASSET_VERSION } from './wasmObjectiveCVersion';
+import { WASM_OCAML_ASSET_VERSION, WASM_OCAML_RUNTIME_PROFILE } from './wasmOcamlVersion';
+import { WASM_OCTAVE_ASSET_VERSION } from './wasmOctaveVersion';
+import { WASM_PASCAL_RUNTIME_BUNDLE } from './wasmPascalVersion';
+import { WASM_PERL_ASSET_VERSION, WASM_PERL_RUNNER_RECEIPT, WASM_PERL_RUNTIME_PROFILE } from './wasmPerlVersion';
+import { WASM_PROLOG_ASSET_VERSION, WASM_PROLOG_RUNNER_RECEIPT, WASM_PROLOG_RUNTIME_PROFILE } from './wasmPrologVersion';
+import { WASM_R_ASSET_VERSION } from './wasmRVersion';
+import { HASKELL_RUNTIME_ASSET_RECEIPTS, RUBY_RUNTIME_BUNDLE, RUBY_RUNTIME_MANIFEST_PATH, RUBY_RUNTIME_MODULE_STORAGE_PATH, RUBY_RUNTIME_WASM_STORAGE_PATH } from '@wasm-idle/core';
+import { WASM_RUST_ASSET_VERSION, WASM_RUST_EXECUTABLE_GRAPH_PROFILE, WASM_RUST_RUNTIME_PROFILE } from './wasmRustVersion';
+import { WASM_SWIFT_ASSET_VERSION } from './wasmSwiftVersion';
+import { WASM_TCL_ASSET_VERSION, WASM_TCL_RUNNER_RECEIPT, WASM_TCL_RUNTIME_PROFILE } from './wasmTclVersion';
+import { WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE, WASM_TINYGO_RUNTIME_PROFILE } from './wasmTinyGoVersion';
+import { WASM_TYPESCRIPT_ASSET_VERSION } from './wasmTypeScriptVersion';
+import { WASM_WAT_ASSET_VERSION } from './wasmWatVersion';
+import { WASM_ZIG_ASSET_RECEIPTS, WASM_ZIG_ASSET_VERSION } from './wasmZigVersion';
+export function normalizeApplicationAssetRootUrl(rootUrl) {
+    const normalized = rootUrl.trim();
+    if (!normalized || normalized === '/')
+        return '';
+    return normalized.replace(/\/+$/u, '');
+}
+export function createApplicationAssetResolver(rootUrl) {
+    const normalizedRootUrl = normalizeApplicationAssetRootUrl(rootUrl);
+    return (assetPath, version) => {
+        const normalizedAssetPath = assetPath.replace(/^\/+/u, '');
+        if (!normalizedAssetPath) {
+            throw new TypeError('Application asset path must not be empty');
+        }
+        const url = `${normalizedRootUrl}/${normalizedAssetPath}`;
+        return version === undefined ? url : `${url}?v=${encodeURIComponent(version)}`;
+    };
+}
+export function createApplicationRuntimeAssets(rootUrl) {
+    const normalizedRootUrl = normalizeApplicationAssetRootUrl(rootUrl);
+    const asset = createApplicationAssetResolver(normalizedRootUrl);
+    return {
+        rootUrl: normalizedRootUrl,
+        assemblyscript: {
+            moduleUrl: asset('wasm-assemblyscript/runtime.mjs', STATIC_RUNTIME_MODULE_VERSION)
+        },
+        duckdb: {
+            moduleUrl: asset('wasm-duckdb/runtime.mjs', STATIC_RUNTIME_MODULE_VERSION)
+        },
+        php: {
+            moduleUrl: asset('wasm-php/runtime.mjs', STATIC_RUNTIME_MODULE_VERSION)
+        },
+        rust: {
+            compilerUrl: `${asset('wasm-rust/index.js', WASM_RUST_ASSET_VERSION)}&rustManifestBytes=${WASM_RUST_RUNTIME_PROFILE.manifestReceipt.bytes}&rustManifestSha256=${WASM_RUST_RUNTIME_PROFILE.manifestReceipt.sha256}`,
+            manifestUrl: asset('wasm-rust/runtime/runtime-manifest.v3.json', WASM_RUST_RUNTIME_PROFILE.manifestFingerprint),
+            ...WASM_RUST_RUNTIME_PROFILE,
+            executableGraphFingerprint: WASM_RUST_EXECUTABLE_GRAPH_PROFILE.fingerprint
+        },
+        go: {
+            compilerUrl: asset('wasm-go/index.js', WASM_GO_ASSET_VERSION),
+            manifestUrl: asset('wasm-go/runtime/runtime-manifest.v1.json', WASM_GO_ASSET_VERSION)
+        },
+        d: {
+            moduleUrl: asset('wasm-d/index.js', WASM_D_INTEGRITY_VERSION),
+            manifestUrl: asset('wasm-d/runtime/runtime-manifest.v1.json', WASM_D_INTEGRITY_VERSION),
+            integrity: WASM_D_OUTER_ASSET_RECEIPTS
+        },
+        dotnet: {
+            moduleUrl: asset('wasm-dotnet/index.js', WASM_DOTNET_ASSET_VERSION)
+        },
+        elixir: {
+            bundleUrl: asset('wasm-elixir/bundle.avm', WASM_ELIXIR_ASSET_VERSION),
+            integrity: WASM_ELIXIR_ASSET_RECEIPTS
+        },
+        erlang: {
+            bundleUrl: asset('wasm-elixir/bundle.avm', WASM_ELIXIR_ASSET_VERSION),
+            integrity: WASM_ELIXIR_ASSET_RECEIPTS
+        },
+        prolog: {
+            baseUrl: asset('wasm-prolog/'),
+            workerUrl: asset('wasm-prolog/runner-worker.js', WASM_PROLOG_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-prolog/runtime-manifest.v2.json', WASM_PROLOG_ASSET_VERSION),
+            ...WASM_PROLOG_RUNTIME_PROFILE,
+            workerReceipt: WASM_PROLOG_RUNNER_RECEIPT
+        },
+        gleam: {
+            baseUrl: asset('wasm-gleam/'),
+            workerUrl: asset('wasm-gleam/runner-worker.js', WASM_GLEAM_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-gleam/source-manifest.v2.json', WASM_GLEAM_ASSET_VERSION),
+            manifestFingerprint: WASM_GLEAM_ASSET_VERSION,
+            workerReceipt: WASM_GLEAM_RUNNER_RECEIPT
+        },
+        perl: {
+            baseUrl: asset('wasm-perl/'),
+            workerUrl: asset('wasm-perl/runner-worker.js', WASM_PERL_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-perl/runtime-manifest.v2.json', WASM_PERL_ASSET_VERSION),
+            ...WASM_PERL_RUNTIME_PROFILE,
+            workerReceipt: WASM_PERL_RUNNER_RECEIPT
+        },
+        tcl: {
+            baseUrl: asset('wasm-tcl/'),
+            workerUrl: asset('wasm-tcl/runner-worker.js', WASM_TCL_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-tcl/runtime-manifest.v2.json', WASM_TCL_ASSET_VERSION),
+            ...WASM_TCL_RUNTIME_PROFILE,
+            workerReceipt: WASM_TCL_RUNNER_RECEIPT
+        },
+        awk: {
+            baseUrl: asset('wasm-awk/'),
+            workerUrl: asset('wasm-awk/runner-worker.v2.js', WASM_AWK_RUNTIME_BUNDLE.workerReceipt.sha256),
+            manifestUrl: asset('wasm-awk/runtime-manifest.v2.json', WASM_AWK_RUNTIME_BUNDLE.profile.manifestFingerprint),
+            ...WASM_AWK_RUNTIME_BUNDLE.profile
+        },
+        pascal: {
+            baseUrl: asset('wasm-pascal/'),
+            workerUrl: asset('wasm-pascal/runner-worker.js', WASM_PASCAL_RUNTIME_BUNDLE.workerReceipt.sha256),
+            manifestUrl: asset('wasm-pascal/runtime-manifest.v2.json', WASM_PASCAL_RUNTIME_BUNDLE.profile.manifestFingerprint),
+            compilerJavaScriptUrl: asset('wasm-pascal/compiler.js.gz.bin', WASM_PASCAL_RUNTIME_BUNDLE.profile.compilerJavaScriptReceipt.sha256),
+            rtlJavaScriptUrl: asset('wasm-pascal/rtl.js.bin', WASM_PASCAL_RUNTIME_BUNDLE.profile.rtlJavaScriptReceipt.sha256),
+            systemPascalUrl: asset('wasm-pascal/system.pas.bin', WASM_PASCAL_RUNTIME_BUNDLE.profile.systemPascalReceipt.sha256),
+            ...WASM_PASCAL_RUNTIME_BUNDLE.profile,
+            workerReceipt: WASM_PASCAL_RUNTIME_BUNDLE.workerReceipt
+        },
+        forth: {
+            baseUrl: asset('wasm-forth/'),
+            workerUrl: asset('wasm-forth/runner-worker.js', WASM_FORTH_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-forth/runtime-manifest.v2.json', WASM_FORTH_ASSET_VERSION),
+            manifestFingerprint: WASM_FORTH_ASSET_VERSION,
+            workerReceipt: WASM_FORTH_RUNNER_RECEIPT
+        },
+        j: {
+            baseUrl: asset('wasm-j/'),
+            workerUrl: asset('wasm-j/runner-worker.js', WASM_J_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-j/runtime-manifest.v2.json', WASM_J_ASSET_VERSION),
+            manifestFingerprint: WASM_J_ASSET_VERSION,
+            workerReceipt: WASM_J_RUNNER_RECEIPT
+        },
+        bqn: {
+            baseUrl: asset('wasm-bqn/'),
+            workerUrl: asset('wasm-bqn/runner-worker.js', WASM_BQN_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-bqn/runtime-manifest.v2.json', WASM_BQN_ASSET_VERSION),
+            manifestFingerprint: WASM_BQN_ASSET_VERSION,
+            workerReceipt: WASM_BQN_RUNNER_RECEIPT
+        },
+        janet: {
+            baseUrl: asset('wasm-janet/'),
+            workerUrl: asset('wasm-janet/runner-worker.js', WASM_JANET_RUNTIME_BUNDLE.workerReceipt.sha256),
+            manifestUrl: asset('wasm-janet/runtime-manifest.v2.json', WASM_JANET_RUNTIME_BUNDLE.profile.manifestFingerprint),
+            ...WASM_JANET_RUNTIME_BUNDLE.profile,
+            workerReceipt: WASM_JANET_RUNTIME_BUNDLE.workerReceipt
+        },
+        julia: {
+            baseUrl: asset('wasm-julia/'),
+            workerUrl: asset('wasm-julia/runner-worker.js', WASM_JULIA_RUNTIME_BUNDLE.workerReceipt.sha256),
+            manifestUrl: asset('wasm-julia/runtime-manifest.v2.json', WASM_JULIA_RUNTIME_BUNDLE.profile.manifestFingerprint),
+            ...WASM_JULIA_RUNTIME_BUNDLE.profile,
+            workerReceipt: WASM_JULIA_RUNTIME_BUNDLE.workerReceipt
+        },
+        nim: {
+            baseUrl: asset('wasm-nim/'),
+            workerUrl: asset('wasm-nim/runner-worker.js', WASM_NIM_RUNTIME_BUNDLE.workerReceipt.sha256),
+            manifestUrl: asset('wasm-nim/runtime-manifest.v2.json', WASM_NIM_RUNTIME_BUNDLE.profile.manifestFingerprint),
+            ...WASM_NIM_RUNTIME_BUNDLE.profile,
+            workerReceipt: WASM_NIM_RUNTIME_BUNDLE.workerReceipt
+        },
+        bash: {
+            baseUrl: asset('wasm-bash/'),
+            manifestUrl: asset('wasm-bash/runtime-manifest.v2.json', WASM_BASH_RUNTIME_PROFILE.manifestFingerprint),
+            moduleUrl: asset('wasm-bash/sdk/index.mjs.bin', WASM_BASH_RUNTIME_PROFILE.sdkJavaScriptReceipt.sha256),
+            wasmerWasmUrl: asset('wasm-bash/sdk/wasmer_js_bg.wasm.gz.bin', WASM_BASH_RUNTIME_PROFILE.wasmerWasmReceipt.sha256),
+            webcUrl: asset('wasm-bash/bash.webc.gz.bin', WASM_BASH_RUNTIME_PROFILE.webcReceipt.sha256),
+            ...WASM_BASH_RUNTIME_PROFILE
+        },
+        clojurescript: {
+            baseUrl: asset('wasm-clojurescript/'),
+            workerUrl: asset('wasm-clojurescript/runner-worker.js', WASM_CLOJURESCRIPT_RUNNER_RECEIPT.sha256),
+            manifestUrl: asset('wasm-clojurescript/runtime-manifest.v2.json', WASM_CLOJURESCRIPT_ASSET_VERSION),
+            manifestFingerprint: WASM_CLOJURESCRIPT_ASSET_VERSION,
+            workerReceipt: WASM_CLOJURESCRIPT_RUNNER_RECEIPT
+        },
+        swift: {
+            baseUrl: asset('wasm-swift/'),
+            workerUrl: asset('wasm-swift/runner-worker.js', WASM_SWIFT_ASSET_VERSION),
+            manifestUrl: asset('wasm-swift/runtime-manifest.v1.json', WASM_SWIFT_ASSET_VERSION)
+        },
+        ocaml: {
+            moduleUrl: asset('wasm-of-js-of-ocaml/browser-native/src/index.js', WASM_OCAML_ASSET_VERSION),
+            manifestUrl: asset('wasm-of-js-of-ocaml/browser-native-bundle/browser-native-manifest.v1.json', WASM_OCAML_ASSET_VERSION),
+            moduleReceipt: WASM_OCAML_RUNTIME_PROFILE.moduleReceipt,
+            manifestReceipt: WASM_OCAML_RUNTIME_PROFILE.manifestReceipt
+        },
+        tinygo: {
+            moduleUrl: asset('wasm-tinygo/upstream.js', WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE.modules[WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE.entryPath].sha256),
+            executableGraphFingerprint: WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE.fingerprint,
+            ...WASM_TINYGO_RUNTIME_PROFILE
+        },
+        typescript: {
+            moduleUrl: asset('wasm-typescript/index.js', WASM_TYPESCRIPT_ASSET_VERSION),
+            libUrl: asset('lsp/typescript-libs.json.gz', WASM_TYPESCRIPT_ASSET_VERSION)
+        },
+        wat: {
+            moduleUrl: asset('wasm-wat/index.js', WASM_WAT_ASSET_VERSION)
+        },
+        lua: {
+            moduleUrl: asset('wasm-lua/index.js', WASM_LUA_ASSET_VERSION)
+        },
+        zig: {
+            compilerUrl: asset('wasm-zig/zig_small.wasm', WASM_ZIG_ASSET_VERSION),
+            stdlibUrl: asset('wasm-zig/std.tar.gz', WASM_ZIG_ASSET_VERSION),
+            integrity: WASM_ZIG_ASSET_RECEIPTS
+        },
+        lisp: {
+            moduleUrl: asset('wasm-lisp/index.js', WASM_LISP_ASSET_VERSION),
+            manifestUrl: asset('wasm-lisp/runtime-manifest.v2.json', WASM_LISP_ASSET_VERSION),
+            manifestFingerprint: WASM_LISP_ASSET_VERSION
+        },
+        ruby: {
+            baseUrl: asset('wasm-ruby/'),
+            manifestUrl: asset(`wasm-ruby/${RUBY_RUNTIME_MANIFEST_PATH}`, RUBY_RUNTIME_BUNDLE.profile.manifestFingerprint),
+            moduleUrl: asset(`wasm-ruby/${RUBY_RUNTIME_MODULE_STORAGE_PATH}`, RUBY_RUNTIME_BUNDLE.profile.moduleJavaScriptReceipt.sha256),
+            wasmUrl: asset(`wasm-ruby/${RUBY_RUNTIME_WASM_STORAGE_PATH}`, RUBY_RUNTIME_BUNDLE.profile.wasmReceipt.sha256),
+            ...RUBY_RUNTIME_BUNDLE.profile
+        },
+        haskell: {
+            moduleUrl: asset('wasm-haskell/dyld.mjs', WASM_HASKELL_ASSET_VERSION),
+            rootfsUrl: asset('wasm-haskell/rootfs.tar.zst', WASM_HASKELL_ASSET_VERSION),
+            bsdtarUrl: asset('wasm-haskell/bsdtar.wasm', WASM_HASKELL_ASSET_VERSION),
+            integrity: HASKELL_RUNTIME_ASSET_RECEIPTS
+        },
+        lfortran: { baseUrl: asset('wasm-lfortran/') },
+        fortran: {
+            baseUrl: asset('wasm-fortran/'),
+            f2cWasmUrl: asset('wasm-fortran/f2c.wasm', WASM_FORTRAN_EXECUTION_ASSET_VERSION),
+            libf2cUrl: asset('wasm-fortran/libf2c.a', WASM_FORTRAN_EXECUTION_ASSET_VERSION),
+            f2cHeaderUrl: asset('wasm-fortran/f2c.h', WASM_FORTRAN_EXECUTION_ASSET_VERSION),
+            analyzerUrl: asset('wasm-fortran/analyzer.js', WASM_FORTRAN_ASSET_VERSION),
+            integrity: WASM_FORTRAN_EXECUTION_ASSET_RECEIPTS
+        },
+        cobol: {
+            baseUrl: asset('wasm-cobol/')
+        },
+        objectivec: {
+            baseUrl: asset('wasm-objectivec/'),
+            libobjcUrl: asset('wasm-objectivec/libobjc.a', WASM_OBJECTIVEC_ASSET_VERSION),
+            headersUrl: asset('wasm-objectivec/headers.json', WASM_OBJECTIVEC_ASSET_VERSION),
+            libgnustepBaseUrl: asset('wasm-objectivec/libgnustep-base.a', WASM_OBJECTIVEC_ASSET_VERSION),
+            libgnustepBaseObjectUrl: asset('wasm-objectivec/libgnustep-base.o', WASM_OBJECTIVEC_ASSET_VERSION),
+            foundationHeadersUrl: asset('wasm-objectivec/foundation-headers.json', WASM_OBJECTIVEC_ASSET_VERSION),
+            libffiUrl: asset('wasm-objectivec/libffi.a', WASM_OBJECTIVEC_ASSET_VERSION),
+            integrity: WASM_OBJECTIVEC_ASSET_RECEIPTS
+        },
+        r: {
+            baseUrl: asset(`webr/${WASM_R_ASSET_VERSION}/`)
+        },
+        octave: {
+            baseUrl: asset('wasm-octave/runtime/'),
+            workerUrl: asset('wasm-octave/runner-worker.js', WASM_OCTAVE_ASSET_VERSION),
+            manifestUrl: asset('wasm-octave/runtime/runtime-manifest.v1.json', WASM_OCTAVE_ASSET_VERSION)
+        },
+        sqlite: {
+            moduleUrl: asset('wasm-sqlite/runtime.mjs', STATIC_RUNTIME_MODULE_VERSION)
+        }
+    };
+}

package/dist/playground/assemblyscript.d.ts

@@ -0,0 +1,41 @@
+import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class AssemblyScriptSandbox 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;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    private beginOperation;
+    private releaseOperation;
+    private isOperationActive;
+    private cleanupOperation;
+    private releaseBeforeSession;
+    private bindPreSessionAbort;
+    private bindAbortSignal;
+    private bindOperationTimeout;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, _args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    private cancelOperation;
+    kill(): void;
+    terminate(reason?: unknown): void;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export default AssemblyScriptSandbox;