wasm-idle 0.7.2 → 1.0.0

package/dist/playground/staticRuntimePreflightProtocol.js

@@ -0,0 +1,339 @@
+import { AssetIntegrityError, AssetNotFoundError, AssetTooLargeError, BusyError, CancelledError, CompileError, DiagnosticLimitError, OutputLimitError, ProtocolError, ResourceLimitError, RuntimeConfigurationError, RuntimeExecutionError, UnsupportedBrowserFeatureError, UnsupportedLanguageError, WasmIdleError, WorkerStartupError, TimeoutError } from '@wasm-idle/core';
+export const STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION = 1;
+function copyStringProperty(value, key) {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+        return undefined;
+    }
+    try {
+        const property = value[key];
+        return typeof property === 'string' ? property : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function copyBooleanProperty(value, key) {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+        return undefined;
+    }
+    try {
+        const property = value[key];
+        return typeof property === 'boolean' ? property : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function copySafeIntegerProperty(value, key) {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+        return undefined;
+    }
+    try {
+        const property = value[key];
+        return Number.isSafeInteger(property) && property >= 0
+            ? property
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function safelyStringify(value) {
+    try {
+        return String(value);
+    }
+    catch {
+        return 'Unknown static runtime preflight error';
+    }
+}
+export function serializeStaticRuntimePreflightError(error) {
+    const name = copyStringProperty(error, 'name') || 'Error';
+    const message = copyStringProperty(error, 'message') ||
+        (typeof error === 'string' ? error : safelyStringify(error));
+    const stack = copyStringProperty(error, 'stack');
+    const code = copyStringProperty(error, 'code');
+    const phase = copyStringProperty(error, 'phase');
+    const runtimeId = copyStringProperty(error, 'runtimeId');
+    const profileId = copyStringProperty(error, 'profileId');
+    const recoverable = copyBooleanProperty(error, 'recoverable');
+    const actual = copySafeIntegerProperty(error, 'actual');
+    const limit = copySafeIntegerProperty(error, 'limit');
+    const timeoutMs = copySafeIntegerProperty(error, 'timeoutMs');
+    const resource = copyStringProperty(error, 'resource');
+    const feature = copyStringProperty(error, 'feature');
+    const languageId = copyStringProperty(error, 'languageId');
+    return {
+        name,
+        message,
+        ...(stack ? { stack } : {}),
+        ...(isRuntimeErrorCode(code) ? { code } : {}),
+        ...(isRuntimePhase(phase) ? { phase } : {}),
+        ...(runtimeId ? { runtimeId } : {}),
+        ...(profileId ? { profileId } : {}),
+        ...(recoverable === undefined ? {} : { recoverable }),
+        ...(actual === undefined ? {} : { actual }),
+        ...(limit === undefined ? {} : { limit }),
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(isRuntimeResourceKind(resource) ? { resource } : {}),
+        ...(feature ? { feature } : {}),
+        ...(languageId ? { languageId } : {})
+    };
+}
+const runtimeErrorCodes = new Set([
+    'unsupported-language',
+    'busy',
+    'runtime-configuration',
+    'asset-not-found',
+    'asset-integrity',
+    'asset-too-large',
+    'worker-startup',
+    'compile',
+    'runtime',
+    'timeout',
+    'cancelled',
+    'resource-limit',
+    'output-limit',
+    'diagnostic-limit',
+    'protocol',
+    'unsupported-browser-feature'
+]);
+const runtimePhases = new Set([
+    'configuration',
+    'asset',
+    'startup',
+    'compile',
+    'execute',
+    'protocol',
+    'dispose'
+]);
+const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+const typedArrayTagGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag)?.get;
+const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'buffer')?.get;
+const typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteLength')?.get;
+const typedArrayByteOffsetGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteOffset')?.get;
+const arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength')?.get;
+function isRuntimeErrorCode(value) {
+    return typeof value === 'string' && runtimeErrorCodes.has(value);
+}
+function isRuntimePhase(value) {
+    return typeof value === 'string' && runtimePhases.has(value);
+}
+function isRuntimeResourceKind(value) {
+    return value === 'wasm-memory' || value === 'nested-workers' || value === 'threads';
+}
+export function inspectStaticRuntimePreflightBytes(value) {
+    if (!typedArrayTagGetter ||
+        !typedArrayBufferGetter ||
+        !typedArrayByteLengthGetter ||
+        !typedArrayByteOffsetGetter ||
+        !arrayBufferByteLengthGetter) {
+        return undefined;
+    }
+    try {
+        if (Reflect.apply(typedArrayTagGetter, value, []) !== 'Uint8Array')
+            return undefined;
+        const buffer = Reflect.apply(typedArrayBufferGetter, value, []);
+        const byteLength = Reflect.apply(typedArrayByteLengthGetter, value, []);
+        const byteOffset = Reflect.apply(typedArrayByteOffsetGetter, value, []);
+        const bufferByteLength = Reflect.apply(arrayBufferByteLengthGetter, buffer, []);
+        return { buffer, bufferByteLength, byteLength, byteOffset };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isStaticRuntimePreflightSerializedError(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const error = value;
+    return (typeof error.name === 'string' &&
+        typeof error.message === 'string' &&
+        (error.stack === undefined || typeof error.stack === 'string') &&
+        (error.code === undefined || isRuntimeErrorCode(error.code)) &&
+        (error.phase === undefined || isRuntimePhase(error.phase)) &&
+        (error.runtimeId === undefined || typeof error.runtimeId === 'string') &&
+        (error.profileId === undefined || typeof error.profileId === 'string') &&
+        (error.recoverable === undefined || typeof error.recoverable === 'boolean') &&
+        (error.actual === undefined ||
+            (Number.isSafeInteger(error.actual) && error.actual >= 0)) &&
+        (error.limit === undefined ||
+            (Number.isSafeInteger(error.limit) && error.limit >= 0)) &&
+        (error.timeoutMs === undefined ||
+            (Number.isSafeInteger(error.timeoutMs) && error.timeoutMs >= 0)) &&
+        (error.resource === undefined || isRuntimeResourceKind(error.resource)) &&
+        (error.feature === undefined || typeof error.feature === 'string') &&
+        (error.languageId === undefined || typeof error.languageId === 'string'));
+}
+export function deserializeStaticRuntimePreflightError(error, fallbackRuntimeId) {
+    const phase = error.phase ?? 'asset';
+    const context = {
+        cause: error,
+        phase,
+        runtimeId: error.runtimeId || fallbackRuntimeId,
+        ...(error.profileId ? { profileId: error.profileId } : {}),
+        ...(error.recoverable === undefined ? {} : { recoverable: error.recoverable })
+    };
+    let deserialized;
+    switch (error.code) {
+        case 'unsupported-language':
+            deserialized = error.languageId
+                ? new UnsupportedLanguageError(error.languageId, context)
+                : new WasmIdleError(error.message, { ...context, code: error.code });
+            break;
+        case 'busy':
+            deserialized = new BusyError(error.message, context);
+            break;
+        case 'runtime-configuration':
+            deserialized = new RuntimeConfigurationError(error.message, context);
+            break;
+        case 'asset-not-found':
+            deserialized = new AssetNotFoundError(error.message, context);
+            break;
+        case 'asset-integrity':
+            deserialized = new AssetIntegrityError(error.message, context);
+            break;
+        case 'asset-too-large':
+            deserialized = new AssetTooLargeError(error.message, {
+                ...context,
+                actual: error.actual,
+                limit: error.limit
+            });
+            break;
+        case 'worker-startup':
+            deserialized = new WorkerStartupError(error.message, context);
+            break;
+        case 'compile':
+            deserialized = new CompileError(error.message, context);
+            break;
+        case 'runtime':
+            deserialized = new RuntimeExecutionError(error.message, context);
+            break;
+        case 'timeout':
+            deserialized =
+                error.timeoutMs === undefined
+                    ? new WasmIdleError(error.message, { ...context, code: error.code })
+                    : new TimeoutError(error.message, {
+                        ...context,
+                        timeoutMs: error.timeoutMs
+                    });
+            break;
+        case 'cancelled':
+            deserialized = new CancelledError(error.message, context);
+            break;
+        case 'resource-limit':
+            deserialized =
+                error.actual === undefined ||
+                    error.limit === undefined ||
+                    error.resource === undefined
+                    ? new WasmIdleError(error.message, { ...context, code: error.code })
+                    : new ResourceLimitError(error.message, {
+                        ...context,
+                        actual: error.actual,
+                        limit: error.limit,
+                        resource: error.resource
+                    });
+            break;
+        case 'output-limit':
+            deserialized =
+                error.actual === undefined || error.limit === undefined
+                    ? new WasmIdleError(error.message, { ...context, code: error.code })
+                    : new OutputLimitError(error.message, {
+                        ...context,
+                        actual: error.actual,
+                        limit: error.limit
+                    });
+            break;
+        case 'diagnostic-limit':
+            deserialized =
+                error.actual === undefined || error.limit === undefined
+                    ? new WasmIdleError(error.message, { ...context, code: error.code })
+                    : new DiagnosticLimitError(error.message, {
+                        ...context,
+                        actual: error.actual,
+                        limit: error.limit
+                    });
+            break;
+        case 'protocol':
+            deserialized = new ProtocolError(error.message, context);
+            break;
+        case 'unsupported-browser-feature':
+            deserialized = error.feature
+                ? new UnsupportedBrowserFeatureError(error.feature, context)
+                : new WasmIdleError(error.message, { ...context, code: error.code });
+            break;
+        default:
+            deserialized = new WorkerStartupError(error.message, context);
+    }
+    if (deserialized.name === 'WasmIdleError' && error.name)
+        deserialized.name = error.name;
+    if (error.stack)
+        deserialized.stack = error.stack;
+    return deserialized;
+}
+export function collectStaticRuntimePreflightTransferables(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new ProtocolError('Static runtime preflight payload must be a plain object', {
+            phase: 'protocol'
+        });
+    }
+    const prototype = Object.getPrototypeOf(payload);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new ProtocolError('Static runtime preflight payload must be a plain object', {
+            phase: 'protocol'
+        });
+    }
+    const transferables = [];
+    const seen = new Set();
+    for (const key of Reflect.ownKeys(payload)) {
+        if (typeof key !== 'string') {
+            throw new ProtocolError('Static runtime preflight payload has a symbol key');
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(payload, key);
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+            throw new ProtocolError('Static runtime preflight payload properties must be enumerable data properties');
+        }
+        const value = descriptor.value;
+        const bytes = inspectStaticRuntimePreflightBytes(value);
+        if (bytes) {
+            if (bytes.byteLength <= 0 ||
+                bytes.byteOffset !== 0 ||
+                bytes.byteLength !== bytes.bufferByteLength ||
+                seen.has(bytes.buffer)) {
+                throw new ProtocolError('Static runtime preflight bytes must own distinct non-empty whole ArrayBuffers');
+            }
+            seen.add(bytes.buffer);
+            transferables.push(bytes.buffer);
+            continue;
+        }
+        if (value !== null &&
+            (typeof value === 'object' || typeof value === 'function' || typeof value === 'symbol')) {
+            throw new ProtocolError('Static runtime preflight payload accepts only primitive scalars and Uint8Arrays');
+        }
+    }
+    if (transferables.length === 0) {
+        throw new ProtocolError('Static runtime preflight payload contains no transferable bytes');
+    }
+    return transferables;
+}
+export function isStaticRuntimePreflightProgress(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const progress = value;
+    if (progress.kind === 'asset') {
+        if (!progress.progress || typeof progress.progress !== 'object')
+            return false;
+        const asset = progress.progress;
+        return (typeof asset.runtimeId === 'string' &&
+            typeof asset.assetKey === 'string' &&
+            Number.isSafeInteger(asset.loadedBytes) &&
+            asset.loadedBytes >= 0 &&
+            Number.isSafeInteger(asset.totalBytes) &&
+            asset.totalBytes >= 0);
+    }
+    return (progress.kind === 'decompression' &&
+        (progress.asset === undefined || progress.asset === 'wasm' || progress.asset === 'data') &&
+        Number.isSafeInteger(progress.loadedBytes) &&
+        progress.loadedBytes >= 0 &&
+        Number.isSafeInteger(progress.totalBytes) &&
+        progress.totalBytes > 0);
+}

package/dist/playground/staticStdinRing.d.ts

@@ -0,0 +1,45 @@
+export declare const STATIC_STDIN_RING_PROTOCOL: "wasm-idle-static-stdin-ring";
+export declare const STATIC_STDIN_RING_PROTOCOL_VERSION: 1;
+export declare const STATIC_STDIN_RING_CONTROL_SLOTS: 4;
+export declare const STATIC_STDIN_RING_CONTROL_BYTES: number;
+export declare const STATIC_STDIN_RING_WRITE_INDEX: 0;
+export declare const STATIC_STDIN_RING_READ_INDEX: 1;
+export declare const STATIC_STDIN_RING_CLOSED_INDEX: 2;
+export declare const STATIC_STDIN_RING_CANCELLED_INDEX: 3;
+export interface StaticStdinRingDescriptor {
+    readonly protocol: typeof STATIC_STDIN_RING_PROTOCOL;
+    readonly protocolVersion: typeof STATIC_STDIN_RING_PROTOCOL_VERSION;
+    readonly buffer: SharedArrayBuffer;
+    readonly capacity: number;
+    readonly controlBytes: typeof STATIC_STDIN_RING_CONTROL_BYTES;
+}
+export interface StaticStdinRingHostOptions {
+    readonly capacity?: number;
+    readonly maxBufferedBytes?: number;
+}
+export declare class StaticStdinRingOverflowError extends RangeError {
+    readonly actual: number;
+    readonly limit: number;
+    constructor(actual: number, limit: number);
+}
+export declare class StaticStdinRingHost {
+    readonly descriptor: StaticStdinRingDescriptor;
+    readonly maxBufferedBytes: number;
+    private readonly control;
+    private readonly data;
+    private readonly pending;
+    private pendingBytes;
+    private pendingOffset;
+    private closeRequested;
+    private cancelled;
+    constructor(options?: StaticStdinRingHostOptions);
+    get bufferedBytes(): number;
+    get isClosed(): boolean;
+    get isCancelled(): boolean;
+    enqueue(input: string): number;
+    close(): void;
+    cancel(): void;
+    consumerRequestedInput(): void;
+    private ringBytes;
+    private flush;
+}

package/dist/playground/staticStdinRing.js

@@ -0,0 +1,158 @@
+export const STATIC_STDIN_RING_PROTOCOL = 'wasm-idle-static-stdin-ring';
+export const STATIC_STDIN_RING_PROTOCOL_VERSION = 1;
+export const STATIC_STDIN_RING_CONTROL_SLOTS = 4;
+export const STATIC_STDIN_RING_CONTROL_BYTES = STATIC_STDIN_RING_CONTROL_SLOTS * Int32Array.BYTES_PER_ELEMENT;
+export const STATIC_STDIN_RING_WRITE_INDEX = 0;
+export const STATIC_STDIN_RING_READ_INDEX = 1;
+export const STATIC_STDIN_RING_CLOSED_INDEX = 2;
+export const STATIC_STDIN_RING_CANCELLED_INDEX = 3;
+export class StaticStdinRingOverflowError extends RangeError {
+    actual;
+    limit;
+    constructor(actual, limit) {
+        super(`Static stdin buffered bytes exceed ${limit}`);
+        this.name = 'StaticStdinRingOverflowError';
+        this.actual = actual;
+        this.limit = limit;
+    }
+}
+const DEFAULT_CAPACITY = 64 * 1024;
+const DEFAULT_MAX_BUFFERED_BYTES = 128 * 1024;
+const inputEncoder = new TextEncoder();
+export class StaticStdinRingHost {
+    descriptor;
+    maxBufferedBytes;
+    control;
+    data;
+    pending = [];
+    pendingBytes = 0;
+    pendingOffset = 0;
+    closeRequested = false;
+    cancelled = false;
+    constructor(options = {}) {
+        const capacity = options.capacity ?? DEFAULT_CAPACITY;
+        const maxBufferedBytes = options.maxBufferedBytes ?? DEFAULT_MAX_BUFFERED_BYTES;
+        for (const [value, name] of [
+            [capacity, 'Static stdin ring capacity'],
+            [maxBufferedBytes, 'Static stdin maximum buffered bytes']
+        ]) {
+            if (!Number.isSafeInteger(value) || value <= 0) {
+                throw new TypeError(`${name} must be a positive safe integer`);
+            }
+        }
+        if (maxBufferedBytes < capacity) {
+            throw new TypeError('Static stdin maximum buffered bytes must cover the ring capacity');
+        }
+        if (typeof SharedArrayBuffer !== 'function') {
+            throw new TypeError('SharedArrayBuffer is required for streaming static stdin');
+        }
+        const buffer = new SharedArrayBuffer(STATIC_STDIN_RING_CONTROL_BYTES + capacity);
+        this.control = new Int32Array(buffer, 0, STATIC_STDIN_RING_CONTROL_SLOTS);
+        this.data = new Uint8Array(buffer, STATIC_STDIN_RING_CONTROL_BYTES, capacity);
+        this.maxBufferedBytes = maxBufferedBytes;
+        this.descriptor = Object.freeze({
+            protocol: STATIC_STDIN_RING_PROTOCOL,
+            protocolVersion: STATIC_STDIN_RING_PROTOCOL_VERSION,
+            buffer,
+            capacity,
+            controlBytes: STATIC_STDIN_RING_CONTROL_BYTES
+        });
+    }
+    get bufferedBytes() {
+        return this.ringBytes() + this.pendingBytes;
+    }
+    get isClosed() {
+        return Atomics.load(this.control, STATIC_STDIN_RING_CLOSED_INDEX) === 1;
+    }
+    get isCancelled() {
+        return this.cancelled;
+    }
+    enqueue(input) {
+        if (this.cancelled)
+            throw new Error('Static stdin ring is cancelled');
+        if (this.closeRequested)
+            throw new Error('Static stdin ring is closed');
+        const bytes = inputEncoder.encode(input);
+        if (bytes.byteLength === 0)
+            return 0;
+        this.flush();
+        const actual = this.bufferedBytes + bytes.byteLength;
+        if (actual > this.maxBufferedBytes) {
+            throw new StaticStdinRingOverflowError(actual, this.maxBufferedBytes);
+        }
+        this.pending.push(bytes);
+        this.pendingBytes += bytes.byteLength;
+        this.flush();
+        return bytes.byteLength;
+    }
+    close() {
+        if (this.cancelled || this.closeRequested)
+            return;
+        this.closeRequested = true;
+        this.flush();
+    }
+    cancel() {
+        if (this.cancelled)
+            return;
+        this.cancelled = true;
+        this.closeRequested = true;
+        this.pending.length = 0;
+        this.pendingBytes = 0;
+        this.pendingOffset = 0;
+        Atomics.store(this.control, STATIC_STDIN_RING_CANCELLED_INDEX, 1);
+        Atomics.store(this.control, STATIC_STDIN_RING_CLOSED_INDEX, 1);
+        Atomics.notify(this.control, STATIC_STDIN_RING_WRITE_INDEX);
+    }
+    consumerRequestedInput() {
+        this.flush();
+    }
+    ringBytes() {
+        const write = Atomics.load(this.control, STATIC_STDIN_RING_WRITE_INDEX);
+        const read = Atomics.load(this.control, STATIC_STDIN_RING_READ_INDEX);
+        const used = write - read;
+        if (used < 0 || used > this.data.byteLength) {
+            throw new Error('Static stdin ring counters are invalid');
+        }
+        return used;
+    }
+    flush() {
+        if (this.cancelled)
+            return;
+        let write = Atomics.load(this.control, STATIC_STDIN_RING_WRITE_INDEX);
+        const read = Atomics.load(this.control, STATIC_STDIN_RING_READ_INDEX);
+        const used = write - read;
+        if (used < 0 || used > this.data.byteLength) {
+            throw new Error('Static stdin ring counters are invalid');
+        }
+        let available = this.data.byteLength - used;
+        let published = false;
+        while (available > 0 && this.pending.length > 0) {
+            const chunk = this.pending[0];
+            const remaining = chunk.byteLength - this.pendingOffset;
+            const count = Math.min(available, remaining);
+            const start = write % this.data.byteLength;
+            const first = Math.min(count, this.data.byteLength - start);
+            this.data.set(chunk.subarray(this.pendingOffset, this.pendingOffset + first), start);
+            if (first < count) {
+                this.data.set(chunk.subarray(this.pendingOffset + first, this.pendingOffset + count), 0);
+            }
+            write += count;
+            available -= count;
+            this.pendingOffset += count;
+            this.pendingBytes -= count;
+            published = true;
+            if (this.pendingOffset === chunk.byteLength) {
+                this.pending.shift();
+                this.pendingOffset = 0;
+            }
+        }
+        if (published)
+            Atomics.store(this.control, STATIC_STDIN_RING_WRITE_INDEX, write);
+        if (this.closeRequested && this.pendingBytes === 0) {
+            Atomics.store(this.control, STATIC_STDIN_RING_CLOSED_INDEX, 1);
+        }
+        if (published || this.closeRequested) {
+            Atomics.notify(this.control, STATIC_STDIN_RING_WRITE_INDEX);
+        }
+    }
+}