@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/compiler/wasm_js_host_runtime.js

@@ -0,0 +1,656 @@
+const SOUNDSCRIPT_CLASS_TAG = '__soundscript_class_tag__';
+const SOUNDSCRIPT_CLASS_CONSTRUCT = '__soundscript_class_construct';
+const SOUNDSCRIPT_CLASS_BASE_CONSTRUCTOR = '__soundscript_class_base_constructor';
+const SOUNDSCRIPT_CLOSURE_REF = Symbol('soundscript_closure_ref');
+const SOUNDSCRIPT_SYNC_AWARE = Symbol('soundscript_sync_aware');
+function isWebAssemblyModule(value) {
+    return typeof WebAssembly.Module === 'function' && value instanceof WebAssembly.Module;
+}
+function isResponseLike(value) {
+    return typeof Response === 'function' && value instanceof Response;
+}
+function isUrlLike(value) {
+    return typeof URL === 'function' && value instanceof URL;
+}
+function isArrayBufferLike(value) {
+    return typeof ArrayBuffer === 'function' && value instanceof ArrayBuffer ||
+        typeof SharedArrayBuffer === 'function' && value instanceof SharedArrayBuffer;
+}
+async function loadNodeFileUrl(url) {
+    if (url.protocol !== 'file:' || !(typeof process === 'object' && process?.versions?.node)) {
+        return undefined;
+    }
+    const fs = await import('node:fs/promises');
+    const bytes = await fs.readFile(url);
+    return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+}
+async function loadDenoFileUrl(url) {
+    const denoNamespace = globalThis.Deno;
+    if (!denoNamespace || url.protocol !== 'file:') {
+        return undefined;
+    }
+    return await denoNamespace.readFile(url);
+}
+async function loadWasmInstantiateSource(wasmSource) {
+    if (isWebAssemblyModule(wasmSource)) {
+        return wasmSource;
+    }
+    if (ArrayBuffer.isView(wasmSource)) {
+        return wasmSource;
+    }
+    if (isArrayBufferLike(wasmSource)) {
+        return new Uint8Array(wasmSource);
+    }
+    if (typeof wasmSource === 'string') {
+        const response = await fetch(wasmSource);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    if (isUrlLike(wasmSource)) {
+        const denoBytes = await loadDenoFileUrl(wasmSource);
+        if (denoBytes) {
+            return denoBytes;
+        }
+        const nodeBytes = await loadNodeFileUrl(wasmSource);
+        if (nodeBytes) {
+            return nodeBytes;
+        }
+        const response = await fetch(wasmSource);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    if (isResponseLike(wasmSource)) {
+        return new Uint8Array(await wasmSource.arrayBuffer());
+    }
+    return wasmSource;
+}
+function createJsHostImports(instanceCell) {
+    const heapIdentityCache = new WeakMap();
+    const hostParamIdentityCache = new WeakMap();
+    const hostPromiseToInternalCache = new WeakMap();
+    const internalPromiseToHostCache = new WeakMap();
+    const classConstructorWrappers = new Map();
+    const getClassMethodSyncExportName = (tag, propertyName) => `__soundscript_sync_class_method_${tag}__${[...new TextEncoder().encode(propertyName)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('')}`;
+    const getClassMethodSyncFromHostExportName = (tag, propertyName) => `__soundscript_sync_from_class_method_${tag}__${[...new TextEncoder().encode(propertyName)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('')}`;
+    const getClassStaticMethodSyncExportName = (tag, propertyName) => `__soundscript_sync_class_static_method_${tag}__${[...new TextEncoder().encode(propertyName)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('')}`;
+    const getClassStaticMethodSyncFromHostExportName = (tag, propertyName) => `__soundscript_sync_from_class_static_method_${tag}__${[...new TextEncoder().encode(propertyName)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('')}`;
+    const expectHeapIdentityKey = (value) => {
+        if ((typeof value !== 'object' && typeof value !== 'function') ||
+            value === null) {
+            throw new TypeError('Expected wasm heap reference for host identity cache.');
+        }
+        return value;
+    };
+    const getOrCreateHostClassConstructor = (tag) => {
+        const existing = classConstructorWrappers.get(tag);
+        if (existing) {
+            return existing;
+        }
+        const wrapper = function SoundscriptClassWrapper(...args) {
+            if (new.target === undefined) {
+                throw new TypeError('Class constructors must be invoked with new.');
+            }
+            const construct = wrapper[SOUNDSCRIPT_CLASS_CONSTRUCT];
+            if (typeof construct !== 'function') {
+                throw new TypeError('Compiled class constructor wrapper is missing construct hook.');
+            }
+            return construct(...args);
+        };
+        Object.defineProperty(wrapper, 'name', {
+            configurable: true,
+            value: `SoundscriptClass${tag}`,
+        });
+        Object.defineProperty(wrapper, Symbol.hasInstance, {
+            configurable: true,
+            value(instance) {
+                if (typeof instance !== 'object' || instance === null) {
+                    return false;
+                }
+                return wrapper.prototype.isPrototypeOf(instance);
+            },
+        });
+        Object.defineProperty(wrapper.prototype, 'constructor', {
+            configurable: true,
+            enumerable: false,
+            value: wrapper,
+            writable: true,
+        });
+        Object.defineProperty(wrapper, SOUNDSCRIPT_CLASS_TAG, {
+            configurable: true,
+            enumerable: false,
+            value: Number(tag),
+            writable: true,
+        });
+        classConstructorWrappers.set(tag, wrapper);
+        return wrapper;
+    };
+    const syncClassPrototype = (value) => {
+        if (typeof value !== 'object' || value === null) {
+            throw new TypeError('Expected JS object for soundscript_object.sync_class_prototype.');
+        }
+        const objectRecord = value;
+        const tag = objectRecord[SOUNDSCRIPT_CLASS_TAG];
+        if (typeof tag !== 'number') {
+            return;
+        }
+        Object.setPrototypeOf(value, getOrCreateHostClassConstructor(Number(tag)).prototype);
+    };
+    const syncHostBoundaryValue = (value) => {
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index += 1) {
+                value[index] = syncHostBoundaryValue(value[index]);
+            }
+            return value;
+        }
+        if (typeof value === 'object' && value !== null) {
+            syncClassPrototype(value);
+        }
+        return value;
+    };
+    const wrapHostMethodIfNeeded = (target, propertyName, value) => {
+        if (typeof value !== 'function') {
+            return value;
+        }
+        if (value[SOUNDSCRIPT_SYNC_AWARE] === true) {
+            return value;
+        }
+        const tag = target[SOUNDSCRIPT_CLASS_TAG];
+        const closureRef = value[SOUNDSCRIPT_CLOSURE_REF];
+        if (typeof tag !== 'number' || closureRef === undefined) {
+            return value;
+        }
+        const instance = instanceCell.instance;
+        if (!instance) {
+            return value;
+        }
+        const syncExportName = typeof target === 'function'
+            ? getClassStaticMethodSyncExportName(Number(tag), propertyName)
+            : getClassMethodSyncExportName(Number(tag), propertyName);
+        const syncFromHostExportName = typeof target === 'function'
+            ? getClassStaticMethodSyncFromHostExportName(Number(tag), propertyName)
+            : getClassMethodSyncFromHostExportName(Number(tag), propertyName);
+        const sync = instance.exports[syncExportName];
+        const syncFromHost = instance.exports[syncFromHostExportName];
+        if (typeof sync !== 'function' && typeof syncFromHost !== 'function') {
+            return value;
+        }
+        const callable = value;
+        const wrapped = function (...args) {
+            if (typeof syncFromHost === 'function') {
+                syncFromHost(closureRef, target);
+            }
+            const result = callable.apply(this, args);
+            if (typeof sync === 'function') {
+                sync(closureRef, target);
+            }
+            return result;
+        };
+        Object.defineProperty(wrapped, SOUNDSCRIPT_CLOSURE_REF, {
+            configurable: true,
+            enumerable: false,
+            value: closureRef,
+            writable: false,
+        });
+        return wrapped;
+    };
+    return {
+        soundscript_array: {
+            empty: () => [],
+            empty_number: () => [],
+            empty_boolean: () => [],
+            clear: (value) => {
+                if (!Array.isArray(value)) {
+                    throw new TypeError('Expected JS array for soundscript_array.clear.');
+                }
+                value.length = 0;
+            },
+            length: (value) => {
+                if (!Array.isArray(value)) {
+                    throw new TypeError('Expected JS array for soundscript_array.length.');
+                }
+                return value.length;
+            },
+            same: (left, right) => Number(Object.is(left, right)),
+            get: (value, index) => {
+                if (!Array.isArray(value)) {
+                    throw new TypeError('Expected JS array for soundscript_array.get.');
+                }
+                return value[Number(index)];
+            },
+            get_number: (value, index) => {
+                if (!Array.isArray(value)) {
+                    throw new TypeError('Expected JS array for soundscript_array.get_number.');
+                }
+                return Number(value[Number(index)]);
+            },
+            get_boolean: (value, index) => {
+                if (!Array.isArray(value)) {
+                    throw new TypeError('Expected JS array for soundscript_array.get_boolean.');
+                }
+                return Boolean(value[Number(index)]) ? 1 : 0;
+            },
+            push: (target, value) => {
+                if (!Array.isArray(target)) {
+                    throw new TypeError('Expected JS array for soundscript_array.push.');
+                }
+                target.push(syncHostBoundaryValue(value));
+            },
+            push_number: (target, value) => {
+                if (!Array.isArray(target)) {
+                    throw new TypeError('Expected JS array for soundscript_array.push_number.');
+                }
+                target.push(Number(value));
+            },
+            push_boolean: (target, value) => {
+                if (!Array.isArray(target)) {
+                    throw new TypeError('Expected JS array for soundscript_array.push_boolean.');
+                }
+                target.push(Boolean(value));
+            },
+        },
+        soundscript_length_view: {
+            length: (value) => {
+                if (value === null ||
+                    value === undefined ||
+                    (!Array.isArray(value) && typeof value !== 'string' &&
+                        (typeof value !== 'object' || value === null || !('length' in value)))) {
+                    throw new TypeError('Expected string, array, or length-bearing object.');
+                }
+                return Number(value.length);
+            },
+            from_length: (value) => ({ length: Number(value) }),
+        },
+        soundscript_object: new Proxy({}, {
+            get(_target, property) {
+                if (property === 'same') {
+                    return (left, right) => Number(left === right);
+                }
+                if (property === 'empty') {
+                    return () => ({});
+                }
+                if (property === 'lookup_cached') {
+                    return (value) => heapIdentityCache.get(expectHeapIdentityKey(value)) ?? null;
+                }
+                if (property === 'remember_cached') {
+                    return (value, hostValue) => {
+                        heapIdentityCache.set(expectHeapIdentityKey(value), hostValue);
+                    };
+                }
+                if (property === 'get_class_tag') {
+                    return (value) => {
+                        if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+                            throw new TypeError('Expected JS object or function for soundscript_object.get_class_tag.');
+                        }
+                        const objectRecord = value;
+                        return typeof objectRecord[SOUNDSCRIPT_CLASS_TAG] === 'number'
+                            ? Number(objectRecord[SOUNDSCRIPT_CLASS_TAG])
+                            : -1;
+                    };
+                }
+                if (property === 'set_class_tag') {
+                    return (value, next) => {
+                        if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+                            throw new TypeError('Expected JS object or function for soundscript_object.set_class_tag.');
+                        }
+                        Object.defineProperty(value, SOUNDSCRIPT_CLASS_TAG, {
+                            configurable: true,
+                            enumerable: false,
+                            value: Number(next),
+                            writable: true,
+                        });
+                    };
+                }
+                if (property === 'class_constructor_from_tag') {
+                    return (tag) => getOrCreateHostClassConstructor(Number(tag));
+                }
+                if (property === 'sync_class_prototype') {
+                    return syncClassPrototype;
+                }
+                if (typeof property !== 'string') {
+                    return undefined;
+                }
+                const expectMapValue = (value) => {
+                    if (!(value instanceof Map)) {
+                        throw new TypeError('Expected JS Map for soundscript_object collection host boundary.');
+                    }
+                    return value;
+                };
+                const expectSetValue = (value) => {
+                    if (!(value instanceof Set)) {
+                        throw new TypeError('Expected JS Set for soundscript_object collection host boundary.');
+                    }
+                    return value;
+                };
+                if (property === 'map_keys') {
+                    return (value) => Array.from(expectMapValue(value).keys(), (entry) => String(entry));
+                }
+                if (property === 'map_values_number') {
+                    return (value) => Array.from(expectMapValue(value).values(), (entry) => Number(entry));
+                }
+                if (property === 'map_values_boolean') {
+                    return (value) => Array.from(expectMapValue(value).values(), (entry) => Boolean(entry));
+                }
+                if (property === 'map_values_string') {
+                    return (value) => Array.from(expectMapValue(value).values(), (entry) => String(entry));
+                }
+                if (property === 'set_values_number') {
+                    return (value) => Array.from(expectSetValue(value).values(), (entry) => Number(entry));
+                }
+                if (property === 'set_values_boolean') {
+                    return (value) => Array.from(expectSetValue(value).values(), (entry) => Boolean(entry));
+                }
+                if (property === 'set_values_string') {
+                    return (value) => Array.from(expectSetValue(value).values(), (entry) => String(entry));
+                }
+                if (property === 'set_values_key') {
+                    return () => '__set_values';
+                }
+                const match = /^(get_number|get_boolean|get_closure|set_number|set_boolean|set_closure|has|get_tagged|set_tagged):(.*)$/
+                    .exec(property);
+                const paramCacheMatch = /^(lookup_param_cached|remember_param_cached):(.*)$/.exec(property);
+                if (paramCacheMatch) {
+                    const kind = paramCacheMatch[1];
+                    const cacheKey = decodeURIComponent(paramCacheMatch[2]);
+                    const expectHostIdentityKey = (value) => {
+                        if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+                            throw new TypeError('Expected JS object for soundscript_object param identity cache.');
+                        }
+                        return value;
+                    };
+                    if (kind === 'lookup_param_cached') {
+                        return (value) => hostParamIdentityCache.get(expectHostIdentityKey(value))?.get(cacheKey) ?? null;
+                    }
+                    return (value, heapValue) => {
+                        const hostKey = expectHostIdentityKey(value);
+                        const existing = hostParamIdentityCache.get(hostKey);
+                        if (existing) {
+                            existing.set(cacheKey, heapValue);
+                            return;
+                        }
+                        const created = new Map();
+                        created.set(cacheKey, heapValue);
+                        hostParamIdentityCache.set(hostKey, created);
+                    };
+                }
+                if (!match) {
+                    return undefined;
+                }
+                const kind = match[1];
+                const propertyName = decodeURIComponent(match[2]);
+                const expectObjectRecord = (value) => {
+                    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+                        throw new TypeError('Expected JS object or function for soundscript_object host boundary.');
+                    }
+                    return value;
+                };
+                switch (kind) {
+                    case 'has':
+                        return (value) => Number(Object.prototype.hasOwnProperty.call(expectObjectRecord(value), propertyName));
+                    case 'get_number':
+                        return (value) => Number(expectObjectRecord(value)[propertyName]);
+                    case 'get_boolean':
+                        return (value) => Number(Boolean(expectObjectRecord(value)[propertyName]));
+                    case 'get_closure':
+                        return (value) => {
+                            const objectRecord = expectObjectRecord(value);
+                            const propertyValue = objectRecord[propertyName];
+                            return typeof propertyValue === 'function'
+                                ? propertyValue.bind(value)
+                                : propertyValue;
+                        };
+                    case 'get_tagged':
+                        return (value) => expectObjectRecord(value)[propertyName];
+                    case 'set_number':
+                        return (value, next) => {
+                            expectObjectRecord(value)[propertyName] = Number(next);
+                        };
+                    case 'set_boolean':
+                        return (value, next) => {
+                            expectObjectRecord(value)[propertyName] = next !== 0;
+                        };
+                    case 'set_closure':
+                        return (value, next) => {
+                            const objectRecord = expectObjectRecord(value);
+                            objectRecord[propertyName] = wrapHostMethodIfNeeded(objectRecord, propertyName, next);
+                        };
+                    case 'set_tagged':
+                        return (value, next) => {
+                            const objectRecord = expectObjectRecord(value);
+                            objectRecord[propertyName] = syncHostBoundaryValue(next);
+                            if (propertyName === SOUNDSCRIPT_CLASS_BASE_CONSTRUCTOR &&
+                                typeof value === 'function' &&
+                                typeof next === 'function') {
+                                Object.setPrototypeOf(value, next);
+                                if (typeof value.prototype === 'object' &&
+                                    value.prototype !== null &&
+                                    typeof next.prototype === 'object' &&
+                                    next.prototype !== null) {
+                                    Object.setPrototypeOf(value.prototype, next.prototype);
+                                }
+                            }
+                        };
+                    default:
+                        return undefined;
+                }
+            },
+        }),
+        soundscript_string: {
+            empty: () => '',
+            from_char_code: (value) => String.fromCharCode(Number(value)),
+            length: (value) => String(value).length,
+            char_at: (value, index) => String(value).charAt(Number(index)),
+            char_code_at: (value, index) => String(value).charCodeAt(Number(index)),
+            to_upper_case: (value) => String(value).toUpperCase(),
+            to_lower_case: (value) => String(value).toLowerCase(),
+            trim: (value) => String(value).trim(),
+            trim_start: (value) => String(value).trimStart(),
+            trim_end: (value) => String(value).trimEnd(),
+            starts_with: (value, search) => Number(String(value).startsWith(String(search))),
+            ends_with: (value, search) => Number(String(value).endsWith(String(search))),
+            includes: (value, search) => Number(String(value).includes(String(search))),
+            index_of: (value, search) => String(value).indexOf(String(search)),
+            last_index_of: (value, search) => String(value).lastIndexOf(String(search)),
+            slice: (value, start, end, hasEnd) => hasEnd
+                ? String(value).slice(Number(start), Number(end))
+                : String(value).slice(Number(start)),
+            substring: (value, start, end, hasEnd) => hasEnd
+                ? String(value).substring(Number(start), Number(end))
+                : String(value).substring(Number(start)),
+            concat: (left, right) => String(left) + String(right),
+            equals: (left, right) => Number(String(left) === String(right)),
+        },
+        soundscript_tagged: {
+            undefined_value: () => undefined,
+            type_tag: (value) => {
+                if (value === undefined) {
+                    return 0;
+                }
+                if (typeof value === 'boolean') {
+                    return 1;
+                }
+                if (typeof value === 'number') {
+                    return 2;
+                }
+                if (typeof value === 'string') {
+                    return 3;
+                }
+                if (typeof value === 'object' || typeof value === 'function') {
+                    if (value === null) {
+                        return 6;
+                    }
+                    return 4;
+                }
+                if (value === null) {
+                    return 6;
+                }
+                throw new Error(`Unsupported tagged host value: ${String(value)}`);
+            },
+            number_value: (value) => Number(value),
+            boolean_value: (value) => Number(Boolean(value)),
+            from_number: (value) => Number(value),
+            from_boolean: (value) => value !== 0,
+        },
+        soundscript_closure: new Proxy({}, {
+            get(_target, property) {
+                if (typeof property !== 'string') {
+                    return undefined;
+                }
+                const callMatch = /^call_(\d+)$/.exec(property);
+                if (callMatch) {
+                    return (callback, ...args) => {
+                        if (typeof callback !== 'function') {
+                            throw new TypeError('Expected JS function for soundscript_closure.call.');
+                        }
+                        return callback(...args);
+                    };
+                }
+                const toHostSyncMatch = /^to_host_sync_(\d+):(.*)$/.exec(property);
+                if (toHostSyncMatch) {
+                    const signatureId = Number(toHostSyncMatch[1]);
+                    const syncExportName = decodeURIComponent(toHostSyncMatch[2] ?? '');
+                    return (target, closure) => {
+                        const wrapped = (...args) => {
+                            const instance = instanceCell.instance;
+                            if (!instance) {
+                                throw new Error('Closure export wrapper invoked before instantiation completed.');
+                            }
+                            const invoke = instance.exports[`__soundscript_closure_invoke_${signatureId}`];
+                            if (typeof invoke !== 'function') {
+                                throw new Error(`Missing exported closure invoker for signature ${signatureId}.`);
+                            }
+                            const sync = instance.exports[syncExportName];
+                            if (typeof sync !== 'function') {
+                                throw new Error(`Missing exported closure sync helper ${syncExportName}.`);
+                            }
+                            const syncFromHostExportName = syncExportName.startsWith('__soundscript_sync_class_method_')
+                                ? syncExportName.replace('__soundscript_sync_class_method_', '__soundscript_sync_from_class_method_')
+                                : syncExportName.startsWith('__soundscript_sync_class_static_method_')
+                                    ? syncExportName.replace('__soundscript_sync_class_static_method_', '__soundscript_sync_from_class_static_method_')
+                                    : null;
+                            const syncFromHost = syncFromHostExportName
+                                ? instance.exports[syncFromHostExportName]
+                                : undefined;
+                            if (typeof syncFromHost === 'function') {
+                                syncFromHost(closure, target);
+                            }
+                            const result = invoke(closure, ...args);
+                            sync(closure, target);
+                            return result;
+                        };
+                        Object.defineProperty(wrapped, SOUNDSCRIPT_CLOSURE_REF, {
+                            configurable: true,
+                            enumerable: false,
+                            value: closure,
+                            writable: false,
+                        });
+                        Object.defineProperty(wrapped, SOUNDSCRIPT_SYNC_AWARE, {
+                            configurable: true,
+                            enumerable: false,
+                            value: true,
+                            writable: false,
+                        });
+                        return wrapped;
+                    };
+                }
+                const toHostMatch = /^to_host_(\d+)$/.exec(property);
+                if (toHostMatch) {
+                    const signatureId = Number(toHostMatch[1]);
+                    return (closure) => {
+                        const wrapped = (...args) => {
+                            const instance = instanceCell.instance;
+                            if (!instance) {
+                                throw new Error('Closure export wrapper invoked before instantiation completed.');
+                            }
+                            const invoke = instance.exports[`__soundscript_closure_invoke_${signatureId}`];
+                            if (typeof invoke !== 'function') {
+                                throw new Error(`Missing exported closure invoker for signature ${signatureId}.`);
+                            }
+                            return invoke(closure, ...args);
+                        };
+                        Object.defineProperty(wrapped, SOUNDSCRIPT_CLOSURE_REF, {
+                            configurable: true,
+                            enumerable: false,
+                            value: closure,
+                            writable: false,
+                        });
+                        return wrapped;
+                    };
+                }
+                return undefined;
+            },
+        }),
+        soundscript_promise: {
+            to_internal: (value, candidate) => {
+                if (!(value instanceof Promise)) {
+                    throw new TypeError('Expected JS Promise for soundscript_promise.to_internal.');
+                }
+                const candidateKey = expectHeapIdentityKey(candidate);
+                const existing = hostPromiseToInternalCache.get(value);
+                if (existing) {
+                    return existing;
+                }
+                const instance = instanceCell.instance;
+                if (!instance) {
+                    throw new Error('Promise bridge invoked before instantiation completed.');
+                }
+                const fulfill = instance.exports.__soundscript_promise_bridge_fulfill;
+                const reject = instance.exports.__soundscript_promise_bridge_reject;
+                if (typeof fulfill !== 'function' || typeof reject !== 'function') {
+                    throw new Error('Missing exported Promise bridge helpers.');
+                }
+                hostPromiseToInternalCache.set(value, candidateKey);
+                internalPromiseToHostCache.set(candidateKey, value);
+                value.then((resolved) => {
+                    fulfill(candidateKey, resolved);
+                }, (reason) => {
+                    reject(candidateKey, reason);
+                });
+                return candidateKey;
+            },
+            to_host: (value) => {
+                const internalPromise = expectHeapIdentityKey(value);
+                const existing = internalPromiseToHostCache.get(internalPromise);
+                if (existing) {
+                    return existing;
+                }
+                const instance = instanceCell.instance;
+                if (!instance) {
+                    throw new Error('Promise bridge invoked before instantiation completed.');
+                }
+                const attach = instance.exports.__soundscript_promise_then_host;
+                if (typeof attach !== 'function') {
+                    throw new Error('Missing exported Promise host attachment helper.');
+                }
+                const created = new Promise((resolve, reject) => {
+                    attach(internalPromise, resolve, reject);
+                });
+                internalPromiseToHostCache.set(internalPromise, created);
+                return created;
+            },
+        },
+    };
+}
+export async function instantiateSoundscriptWasmModule(wasmSource, options = {}) {
+    const source = await loadWasmInstantiateSource(wasmSource);
+    const instanceCell = { instance: null };
+    const userImports = options.imports ?? {};
+    const importedHostFunctions = userImports.soundscript_host_function ?? {};
+    const hostFunctionImports = Object.fromEntries(Object.entries({
+        ...importedHostFunctions,
+        ...(options.hostFunctions ?? {}),
+    }).map(([name, func]) => [name, (...args) => func(...args)]));
+    const instantiated = await WebAssembly.instantiate(source, {
+        ...createJsHostImports(instanceCell),
+        ...userImports,
+        soundscript_host_function: hostFunctionImports,
+    });
+    const instance = 'instance' in instantiated ? instantiated.instance : instantiated;
+    instanceCell.instance = instance;
+    return instance;
+}