wasm-idle 1.0.7 → 1.0.9

package/dist/playground/grain.d.ts

@@ -0,0 +1,9 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+/** Upstream Grain compiler (js_of_ocaml build) plus a WASI host for the program it emits. */
+declare class Grain extends StaticWorkerRuntimeSandbox {
+    readonly memoryEvidence: {
+        current: unknown;
+    };
+    constructor();
+}
+export default Grain;

package/dist/playground/grain.js

@@ -0,0 +1,127 @@
+import { resolveGrainBaseUrl } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { bundledGrainProfile as profile, bundledGrainWorkerReceipt } from './wasmGrainVersion';
+import { preflightRuntimeAssets } from '@wasm-idle/core';
+const registry = {
+    schemaVersion: 2,
+    manifestId: 'wasm-idle/grain-preflight',
+    revision: profile.compilerJavaScript.sha256,
+    runtimes: [
+        {
+            runtimeId: 'GRAIN',
+            identity: {
+                languageId: 'GRAIN',
+                implementationId: 'grainc',
+                implementationVersion: profile.grainVersion,
+                profile: {
+                    profileId: profile.profileId,
+                    manifestSchemaVersion: 1,
+                    manifestSha256: profile.compilerJavaScript.sha256,
+                    protocolVersion: 1,
+                    trustProfileId: 'wasm-idle-static-worker-v1',
+                    trustProfileSchemaVersion: 1
+                }
+            },
+            capabilities: {
+                stdin: 'streaming',
+                workspace: true,
+                abort: true,
+                artifacts: false,
+                streamingOutput: true
+            },
+            workerLifetime: { mode: 'per-run' },
+            requiredBrowserFeatures: ['wasm'],
+            assetRoot: '.',
+            assets: [
+                {
+                    key: 'compilerBytes',
+                    path: 'grainc.js.gz.bin',
+                    mediaType: 'text/javascript',
+                    compressedSha256: profile.compilerStorage.sha256,
+                    compressedBytes: profile.compilerStorage.bytes,
+                    uncompressedSha256: profile.compilerJavaScript.sha256,
+                    uncompressedBytes: profile.compilerJavaScript.bytes,
+                    encoding: 'gzip'
+                },
+                {
+                    key: 'stdlibBytes',
+                    path: 'stdlib.pack.gz.bin',
+                    mediaType: 'application/octet-stream',
+                    compressedSha256: profile.stdlibStorage.sha256,
+                    compressedBytes: profile.stdlibStorage.bytes,
+                    uncompressedSha256: profile.stdlibPack.sha256,
+                    uncompressedBytes: profile.stdlibPack.bytes,
+                    encoding: 'gzip'
+                }
+            ],
+            contracts: {
+                routeId: 'grain',
+                runtimeAssetKey: 'grain',
+                documentationId: 'GRAIN',
+                syncTarget: 'sync:wasm-grain',
+                browserTestId: 'browser:grain'
+            }
+        }
+    ]
+};
+/** Upstream Grain compiler (js_of_ocaml build) plus a WASI host for the program it emits. */
+class Grain extends StaticWorkerRuntimeSandbox {
+    memoryEvidence;
+    constructor() {
+        const memoryEvidence = { current: undefined };
+        super({
+            displayName: 'Grain',
+            languageId: 'GRAIN',
+            defaultActivePath: 'main.gr',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\bFile\.(?:fdRead|stdin)\b|"wasi\/file"/u
+            },
+            inlineVerifiedWorker: true,
+            moduleWorker: true,
+            includeExecutionLimits: true,
+            enforcePhaseTimeouts: true,
+            onEvidence(evidence) {
+                memoryEvidence.current = evidence;
+            },
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const baseUrl = resolveGrainBaseUrl(runtimeAssets, currentUrl);
+                return {
+                    baseUrl,
+                    workerUrl: new URL('runner-worker.js', baseUrl).href,
+                    manifestUrl: new URL('runtime-build.json', baseUrl).href,
+                    manifestFingerprint: profile.compilerJavaScript.sha256,
+                    preflightKey: profile.stdlibPack.sha256,
+                    workerReceipt: bundledGrainWorkerReceipt
+                };
+            },
+            async preflightRuntimeAssets(urls, context) {
+                memoryEvidence.current = undefined;
+                const result = await preflightRuntimeAssets({
+                    manifest: registry,
+                    runtimeId: 'GRAIN',
+                    rootUrl: urls.baseUrl,
+                    limits: context.limits,
+                    persistentCache: context.persistentCache,
+                    signal: context.signal,
+                    redirect: 'error',
+                    requireExactResponseUrl: true,
+                    maxTotalDeliveryBytes: profile.compilerStorage.bytes + profile.stdlibStorage.bytes,
+                    reportProgress(progress) {
+                        context.reportProgress(0.1, `Preflighting Grain ${progress.assetKey}`);
+                    }
+                });
+                return context.createOwnedDelivery(Object.freeze({
+                    protocol: 'wasm-idle-grain-preflight',
+                    profileId: profile.profileId,
+                    compilerBytes: result.assets.compilerBytes.bytes,
+                    stdlibBytes: result.assets.stdlibBytes.bytes
+                }));
+            }
+        });
+        this.memoryEvidence = memoryEvidence;
+    }
+}
+export default Grain;

package/dist/playground/hy.d.ts

@@ -0,0 +1,21 @@
+import Python from './python';
+import { type PlaygroundRuntimeAssets } from './assets';
+export type HyWorkerExtension = {
+    language: 'hy';
+    version: string;
+    wheels: {
+        url: string;
+        fileName: string;
+        bytes: number;
+        sha256: string;
+    }[];
+};
+/**
+ * Hy runs on the shared Pyodide worker: the pinned Hy and funcparserlib wheels are fetched from
+ * local static assets, verified against code-pinned receipts, and unpacked into site-packages.
+ */
+declare class Hy extends Python {
+    protected readonly workerLanguage: "hy";
+    protected workerLoadExtension(runtimeAssets: string | PlaygroundRuntimeAssets, currentUrl: string): HyWorkerExtension;
+}
+export default Hy;

package/dist/playground/hy.js

@@ -0,0 +1,24 @@
+import Python from './python';
+import { resolveHyBaseUrl } from './assets';
+import { WASM_HY_VERSION, WASM_HY_WHEELS } from './wasmHyVersion';
+/**
+ * Hy runs on the shared Pyodide worker: the pinned Hy and funcparserlib wheels are fetched from
+ * local static assets, verified against code-pinned receipts, and unpacked into site-packages.
+ */
+class Hy extends Python {
+    workerLanguage = 'hy';
+    workerLoadExtension(runtimeAssets, currentUrl) {
+        const baseUrl = resolveHyBaseUrl(runtimeAssets, currentUrl);
+        return {
+            language: 'hy',
+            version: WASM_HY_VERSION,
+            wheels: WASM_HY_WHEELS.map((wheel) => ({
+                url: `${baseUrl}${wheel.fileName}`,
+                fileName: wheel.fileName,
+                bytes: wheel.bytes,
+                sha256: wheel.sha256
+            }))
+        };
+    }
+}
+export default Hy;

package/dist/playground/index.d.ts

@@ -1,6 +1,6 @@
 import type { BoundSandbox, PlaygroundBinding, Sandbox, SandboxRuntimeAssets } from './sandbox';
 import { type PlaygroundBindingOptions } from '@wasm-idle/core';
-export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "C3" | "PYTHON3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "FORTRAN" | "LFORTRAN" | "COBOL" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "WASM" | "LUA" | "ZIG" | "LISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "PHP")[];
+export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "OBJECTIVECXX" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "RESCRIPT" | "C3" | "PYTHON3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "GRAIN" | "HY" | "FORTRAN" | "LFORTRAN" | "COBOL" | "V" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "WASM" | "LUA" | "FENNEL" | "ZIG" | "LISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "POSTGRESQL" | "PHP")[];
 export declare function createPlaygroundBinding(runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): PlaygroundBinding;
 declare function playground(language: string): Promise<Sandbox>;
 declare function playground(language: string, runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): Promise<BoundSandbox>;

package/dist/playground/index.js

@@ -14,6 +14,13 @@ const sandboxRoutes = [
             return new Python();
         }
     },
+    {
+        languageId: 'HY',
+        load: async () => {
+            const { default: Hy } = await import('./hy');
+            return new Hy();
+        }
+    },
     {
         languageId: 'C',
         load: async () => {
@@ -35,6 +42,13 @@ const sandboxRoutes = [
             return new ObjectiveC();
         }
     },
+    {
+        languageId: 'OBJECTIVECXX',
+        load: async () => {
+            const { default: ObjectiveC } = await import('./objectivec');
+            return new ObjectiveC('OBJECTIVECXX');
+        }
+    },
     {
         languageId: 'JAVA',
         load: async () => {
@@ -112,6 +126,13 @@ const sandboxRoutes = [
             return new Gleam();
         }
     },
+    {
+        languageId: 'GRAIN',
+        load: async () => {
+            const { default: Grain } = await import('./grain');
+            return new Grain();
+        }
+    },
     {
         languageId: 'PERL',
         load: async () => {
@@ -147,6 +168,13 @@ const sandboxRoutes = [
             return new ClojureScript();
         }
     },
+    {
+        languageId: 'RESCRIPT',
+        load: async () => {
+            const { default: ReScript } = await import('./rescript');
+            return new ReScript();
+        }
+    },
     {
         languageId: 'FORTH',
         load: async () => {
@@ -217,6 +245,13 @@ const sandboxRoutes = [
             return new Cobol();
         }
     },
+    {
+        languageId: 'V',
+        load: async () => {
+            const { default: VLang } = await import('./v');
+            return new VLang();
+        }
+    },
     {
         languageId: 'TINYGO',
         load: async () => {
@@ -273,6 +308,13 @@ const sandboxRoutes = [
             return new Lua();
         }
     },
+    {
+        languageId: 'FENNEL',
+        load: async () => {
+            const { default: Fennel } = await import('./fennel');
+            return new Fennel();
+        }
+    },
     {
         languageId: 'ZIG',
         load: async () => {
@@ -329,6 +371,13 @@ const sandboxRoutes = [
             return new Sqlite();
         }
     },
+    {
+        languageId: 'POSTGRESQL',
+        load: async () => {
+            const { default: Postgresql } = await import('./postgresql');
+            return new Postgresql();
+        }
+    },
     {
         languageId: 'PHP',
         load: async () => {

package/dist/playground/lua.d.ts

@@ -1,6 +1,20 @@
 import { type PlaygroundRuntimeAssets } from './assets';
 import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
+/**
+ * Describes a language that runs on the wasm-lua (wasmoon) VM. Lua itself uses the
+ * default dialect; Fennel reuses this sandbox and worker with the pinned fennel.lua compiler.
+ */
+export interface LuaSandboxDialect {
+    label: string;
+    runtimeId: string;
+    defaultActivePath: string;
+    /**
+     * Extra worker load fields. The value is also part of the worker identity, so a change
+     * replaces the loaded worker.
+     */
+    resolveWorkerLoadExtras?: (runtimeAssets: string | PlaygroundRuntimeAssets, currentUrl: string) => Record<string, unknown>;
+}
 declare class Lua implements Sandbox {
     output: any;
     worker?: Worker;
@@ -17,8 +31,13 @@ declare class Lua implements Sandbox {
     private activeOperation;
     private disposed;
     private disposePromise;
+    private readonly dialect;
+    private readonly label;
+    private readonly runtimeId;
+    private workerIdentity;
     private readonly disposeCancellation;
     private readonly workerSession;
+    constructor(dialect?: LuaSandboxDialect);
     private requireOperationIdle;
     private beginOperation;
     private isOperationActive;

package/dist/playground/lua.js

@@ -6,9 +6,16 @@ import { createWasmIdleSharedBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
 import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
 const OUTPUT_ENCODER = new TextEncoder();
-const abortReason = (signal, phase) => signal.reason !== undefined
+const abortReason = (signal, phase, label) => signal.reason !== undefined
     ? signal.reason
-    : new DOMException(phase === 'startup' ? 'Lua runtime startup aborted' : 'Lua execution aborted', 'AbortError');
+    : new DOMException(phase === 'startup'
+        ? `${label} runtime startup aborted`
+        : `${label} execution aborted`, 'AbortError');
+const LUA_DIALECT = {
+    label: 'Lua',
+    runtimeId: 'LUA',
+    defaultActivePath: 'main.lua'
+};
 class Lua {
     output = null;
     worker = null;
@@ -25,34 +32,45 @@ class Lua {
     activeOperation = null;
     disposed = false;
     disposePromise = null;
-    disposeCancellation = new CancelledError('Lua sandbox disposed', {
-        phase: 'dispose',
-        runtimeId: 'LUA',
-        recoverable: false
-    });
-    workerSession = new WorkerSession({
-        label: 'Lua',
-        onDispose: (worker) => {
-            if (this.worker === worker)
-                delete this.worker;
-            this.exit = true;
-            this.waitingForInput = false;
-            this.pendingEof = false;
-        }
-    });
+    dialect;
+    label;
+    runtimeId;
+    workerIdentity = '';
+    disposeCancellation;
+    workerSession;
+    constructor(dialect = LUA_DIALECT) {
+        this.dialect = dialect;
+        this.label = dialect.label;
+        this.runtimeId = dialect.runtimeId;
+        this.disposeCancellation = new CancelledError(`${this.label} sandbox disposed`, {
+            phase: 'dispose',
+            runtimeId: this.runtimeId,
+            recoverable: false
+        });
+        this.workerSession = new WorkerSession({
+            label: this.label,
+            onDispose: (worker) => {
+                if (this.worker === worker)
+                    delete this.worker;
+                this.exit = true;
+                this.waitingForInput = false;
+                this.pendingEof = false;
+            }
+        });
+    }
     requireOperationIdle() {
         if (!this.activeOperation)
             return;
-        throw new BusyError('Lua runtime already has an active operation', {
-            runtimeId: 'LUA',
+        throw new BusyError(`${this.label} runtime already has an active operation`, {
+            runtimeId: this.runtimeId,
             phase: this.activeOperation.phase
         });
     }
     beginOperation(phase) {
         if (this.disposed) {
-            throw new RuntimeConfigurationError('Lua sandbox is disposed', {
+            throw new RuntimeConfigurationError(`${this.label} sandbox is disposed`, {
                 phase: 'dispose',
-                runtimeId: 'LUA'
+                runtimeId: this.runtimeId
             });
         }
         this.requireOperationIdle();
@@ -113,7 +131,7 @@ class Lua {
                 return;
             let reason;
             try {
-                reason = abortReason(signal, operation.phase);
+                reason = abortReason(signal, operation.phase, this.label);
             }
             catch (error) {
                 reason = error;
@@ -149,7 +167,7 @@ class Lua {
                 return;
             let reason;
             try {
-                reason = abortReason(signal, operation.phase);
+                reason = abortReason(signal, operation.phase, this.label);
             }
             catch (error) {
                 reason = error;
@@ -189,9 +207,9 @@ class Lua {
                 if (!this.isOperationActive(operation))
                     return;
                 const label = operation.phase === 'startup' ? 'startup' : 'execution';
-                this.cancelOperation(operation, new TimeoutError(`Lua ${label} timed out after ${timeoutMs} ms`, {
+                this.cancelOperation(operation, new TimeoutError(`${this.label} ${label} timed out after ${timeoutMs} ms`, {
                     phase: operation.phase,
-                    runtimeId: 'LUA',
+                    runtimeId: this.runtimeId,
                     timeoutMs
                 }));
             }, timeoutMs);
@@ -234,11 +252,11 @@ class Lua {
             signal = options.signal;
             unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Lua runtime startup cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.label} runtime startup cancelled`));
             }
             limits = resolveExecutionLimits(options.limits);
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Lua runtime startup cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.label} runtime startup cancelled`));
             }
             unbindPreSessionAbort();
         }
@@ -246,7 +264,7 @@ class Lua {
             return Promise.reject(this.releaseBeforeSession(activeOperation, error));
         }
         if (!this.isOperationActive(activeOperation)) {
-            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Lua runtime startup cancelled'));
+            return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.label} runtime startup cancelled`));
         }
         const loadPromise = this.workerSession.load(async (resolve, reject) => {
             const resolveLoad = () => {
@@ -274,8 +292,13 @@ class Lua {
                 if (!nextModuleUrl) {
                     return rejectLoad('Lua runtime is not configured. Set PUBLIC_WASM_LUA_MODULE_URL or runtimeAssets.lua.moduleUrl.');
                 }
-                const needsWorkerReset = !this.worker || this.moduleUrl !== nextModuleUrl;
+                const loadExtras = this.dialect.resolveWorkerLoadExtras?.(runtimeAssets, currentUrl) ?? {};
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                const nextWorkerIdentity = JSON.stringify([nextModuleUrl, loadExtras]);
+                const needsWorkerReset = !this.worker || this.workerIdentity !== nextWorkerIdentity;
                 this.moduleUrl = nextModuleUrl;
+                this.workerIdentity = nextWorkerIdentity;
                 if (needsWorkerReset && this.worker) {
                     this.workerSession.reset();
                 }
@@ -320,6 +343,7 @@ class Lua {
                     };
                     worker.onmessage = handler;
                     worker.postMessage({
+                        ...loadExtras,
                         load: true,
                         moduleUrl: this.moduleUrl
                     });
@@ -392,12 +416,12 @@ class Lua {
             signal = options.signal;
             unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
             if (!this.isOperationActive(activeOperation)) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Lua execution cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.label} execution cancelled`));
             }
-            executionArgs = resolveSandboxExecutionArgs('LUA', args, options);
+            executionArgs = resolveSandboxExecutionArgs(this.runtimeId, args, options);
             limits = resolveExecutionLimits(options.limits);
             const workspaceFiles = options.workspaceFiles ?? [];
-            const activePath = options.activePath ?? 'main.lua';
+            const activePath = options.activePath ?? this.dialect.defaultActivePath;
             const workspaceLimits = options.workspaceLimits;
             workspace = validateExecutionWorkspace(code, workspaceFiles, activePath, {
                 ...workspaceLimits,
@@ -406,7 +430,7 @@ class Lua {
             });
             stdin = options.stdin;
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Lua execution cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.label} execution cancelled`));
             }
             unbindPreSessionAbort();
         }
@@ -414,7 +438,7 @@ class Lua {
             return Promise.reject(this.releaseBeforeSession(activeOperation, error));
         }
         if (!this.isOperationActive(activeOperation)) {
-            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Lua execution cancelled'));
+            return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.label} execution cancelled`));
         }
         const hasExplicitStdin = stdin !== undefined;
         if (hasExplicitStdin) {
@@ -476,7 +500,7 @@ class Lua {
                     if (buffer && !hasExplicitStdin) {
                         this.waitingForInput = true;
                         if (!prepare) {
-                            reportWorkerInputReady(_prog, 'Lua runtime ready for input');
+                            reportWorkerInputReady(_prog, `${this.label} runtime ready for input`);
                             if (!ownsRun())
                                 return;
                         }
@@ -490,11 +514,11 @@ class Lua {
                     if (output) {
                         const actual = outputBytes + OUTPUT_ENCODER.encode(String(output)).byteLength;
                         if (actual > limits.maxOutputBytes) {
-                            failRun(new OutputLimitError(`Lua output exceeded ${limits.maxOutputBytes} bytes`, {
+                            failRun(new OutputLimitError(`${this.label} output exceeded ${limits.maxOutputBytes} bytes`, {
                                 actual,
                                 limit: limits.maxOutputBytes,
                                 phase: 'execute',
-                                runtimeId: 'LUA'
+                                runtimeId: this.runtimeId
                             }), true);
                             return;
                         }
@@ -506,11 +530,11 @@ class Lua {
                     if (diagnostic) {
                         const actual = diagnosticCount + 1;
                         if (actual > limits.maxDiagnostics) {
-                            failRun(new DiagnosticLimitError(`Lua diagnostics exceeded ${limits.maxDiagnostics} messages`, {
+                            failRun(new DiagnosticLimitError(`${this.label} diagnostics exceeded ${limits.maxDiagnostics} messages`, {
                                 actual,
                                 limit: limits.maxDiagnostics,
                                 phase: 'execute',
-                                runtimeId: 'LUA'
+                                runtimeId: this.runtimeId
                             }), true);
                             return;
                         }
@@ -613,6 +637,7 @@ class Lua {
         const activeOperation = this.activeOperation;
         delete this.worker;
         this.moduleUrl = '';
+        this.workerIdentity = '';
         this.output = null;
         this.oncompilerdiagnostic = undefined;
         this.resetExplicitStdinState();

package/dist/playground/objectivec.d.ts

@@ -3,8 +3,9 @@ import type { DebugCommand, DebugSessionEvent } from './options';
 import { type PlaygroundRuntimeAssets } from './assets';
 import type { SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
+export type ObjectiveCSandboxLanguage = 'OBJC' | 'OBJECTIVECXX';
 declare class ObjectiveC implements Sandbox {
-    language: string;
+    language: ObjectiveCSandboxLanguage;
     output?: (data: string) => void;
     ondebug?: (event: DebugSessionEvent) => void;
     worker?: Worker;
@@ -24,6 +25,7 @@ declare class ObjectiveC implements Sandbox {
     assetBridge: WorkerAssetBridge | null;
     activeObjectiveCAssetsKey: string;
     private readonly workerSession;
+    constructor(language?: ObjectiveCSandboxLanguage);
     load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
     write(input: string): void;
     eof(): void;

package/dist/playground/objectivec.js

@@ -9,7 +9,7 @@ import { AssetTooLargeError, createRuntimeAssetsKey, resolveExecutionLimits } fr
 const debugBreakpointBufferInts = 1028;
 const objectiveCAssetsKey = (assets) => createRuntimeAssetsKey({ objectivec: assets }) || '';
 class ObjectiveC {
-    language = 'OBJC';
+    language;
     output;
     ondebug;
     worker = null;
@@ -49,6 +49,9 @@ class ObjectiveC {
             this.ondebug?.({ type: 'stop' });
         }
     });
+    constructor(language = 'OBJC') {
+        this.language = language;
+    }
     load(runtimeAssets = '', code = '', log = true, args = [], options = {}, progress) {
         let limits;
         try {
@@ -220,7 +223,8 @@ class ObjectiveC {
                 log,
                 compileArgs,
                 programArgs,
-                activePath: options.activePath,
+                activePath: options.activePath ||
+                    (this.language === 'OBJECTIVECXX' ? 'main.mm' : undefined),
                 workspaceFiles: options.workspaceFiles,
                 debug: !!options.debug,
                 breakpoints: [...(options.breakpoints || [])],

package/dist/playground/options.js

@@ -1,7 +1,7 @@
 function cloneArgs(value) {
     return Array.isArray(value) ? [...value] : [];
 }
-const compileArgLanguages = new Set(['C', 'CPP', 'OBJC']);
+const compileArgLanguages = new Set(['C', 'CPP', 'OBJC', 'OBJECTIVECXX']);
 export function resolveSandboxExecutionArgs(language, args = [], options = {}) {
     if (compileArgLanguages.has(language)) {
         return {

package/dist/playground/postgresql.d.ts

@@ -0,0 +1,36 @@
+import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Postgresql implements Sandbox {
+    output: any;
+    worker?: Worker;
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    moduleUrl: string;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    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 Postgresql;