wasm-idle 0.7.2 → 1.0.0

package/dist/playground/awk.d.ts

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

package/dist/playground/awk.js

@@ -0,0 +1,60 @@
+import { resolveAwkRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, preflightAwkRuntimeAssets, snapshotAwkRuntimePreflightProfile } from '@wasm-idle/core';
+class Awk extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'AWK',
+            displayName: 'AWK',
+            defaultActivePath: 'main.awk',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\bgetline\b|\$[0-9]|\b(NR|FNR|NF)\b|(^|\n)\s*(?:\/|[!$({]|[A-Za-z_]\w*\s*(?:\(|==|!=|~|!~|<|>|<=|>=))/
+            },
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            inlineVerifiedWorker: true,
+            requireExactWorkerResponseUrl: true,
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveAwkRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotAwkRuntimePreflightProfile(resolved.preflightProfile);
+                if (profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    profile.workerReceipt.bytes !== resolved.workerReceipt.bytes ||
+                    profile.workerReceipt.sha256 !== resolved.workerReceipt.sha256) {
+                    throw new RuntimeConfigurationError('AWK runtime requires one coherent preflight profile and runner receipt.', { runtimeId: 'AWK' });
+                }
+                return { ...resolved, preflightProfile: profile };
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const resolved = urls;
+                const profile = resolved.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalDownloadBytes = [
+                    profile.manifestReceipt.bytes,
+                    profile.goShimReceipt.bytes,
+                    profile.wasmReceipt.bytes
+                ].reduce((total, bytes) => total + (bytes ?? 0), 0);
+                const totalDecompressedBytes = profile.wasmReceipt.uncompressedBytes ?? 0;
+                const payload = await preflightAwkRuntimeAssets({
+                    baseUrl: resolved.baseUrl,
+                    manifestUrl: resolved.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 AWK asset ${progress.assetKey}`);
+                    },
+                    reportDecompressionProgress(loadedBytes) {
+                        const fraction = totalDecompressedBytes > 0 ? loadedBytes / totalDecompressedBytes : 0;
+                        context.reportProgress(0.14 + Math.min(1, fraction) * 0.03, 'Decompressing verified AWK runtime');
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Awk;

package/dist/playground/bash.d.ts

@@ -0,0 +1,53 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Bash implements Sandbox {
+    output?: (data: string) => void;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    webcUrl: string;
+    pendingInput: string[];
+    pendingEof: boolean;
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    private activeOperation;
+    private readyWorker;
+    private loadedConfig;
+    private requestUid;
+    private sessionUid;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    run(code: string, prepare: boolean, log?: boolean, progress?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    write(input: string): void;
+    eof(): void;
+    kill(): void;
+    terminate(reason?: unknown): void;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+    private isActive;
+    private requireActive;
+    private requireConfig;
+    private retireDelivery;
+    private bindAbort;
+    private bindTimeout;
+    private cleanupOperation;
+    private finishOperation;
+    private failOperation;
+    private createWorker;
+    private dispatchLoad;
+    private dispatchRun;
+    private postMessage;
+    private handleWorkerMessage;
+    private handleOutput;
+    private flushDecodedOutput;
+    private flushStdin;
+    private handleWorkerFailure;
+    private handleWorkerProtocolFailure;
+    private failProtocol;
+    private deserializeWorkerError;
+    private retireWorker;
+}
+export default Bash;