wasm-game-ts 0.1.0

package/dist/package.js

@@ -0,0 +1,765 @@
+let cachedPreprocess = null;
+async function getPreprocessFn() {
+    if (!cachedPreprocess) {
+        cachedPreprocess = import('preprocess-wasm-bytes').then((m) => {
+            const fn = m?.preprocess_wasm_bytes;
+            if (typeof fn !== 'function') {
+                throw new Error('preprocess-wasm-bytes missing export preprocess_wasm_bytes(bytes)');
+            }
+            return fn;
+        });
+    }
+    return cachedPreprocess;
+}
+async function preprocessWasmIfNeeded(path, bytes) {
+    // Only wasm files
+    if (!/\.wasm$/i.test(path))
+        return bytes;
+    //return bytes; // return early for now, TESTING
+    try {
+        //console.log('preprocessWasmIfNeeded', path);
+        const preprocess = await getPreprocessFn();
+        // Optional: user can enable verbose logging by setting:
+        // globalThis.__WASM_PREPROCESS_DEBUG__ = true;
+        // before calling the picker/import APIs.
+        console.time(`[preprocess] ${path}`);
+        const out = preprocess(bytes, { debug: true });
+        console.timeEnd(`[preprocess] ${path}`);
+        if (!(out instanceof Uint8Array)) {
+            console.warn('[ImmutablePackage] preprocess_wasm_bytes returned non-Uint8Array; using original wasm:', path);
+            return bytes;
+        }
+        // Helpful debug line (safe even if they don't enable the package debug flag)
+        console.log('[ImmutablePackage] Preprocessed wasm:', path, `(${bytes.byteLength} -> ${out.byteLength} bytes)`);
+        return out;
+    }
+    catch (err) {
+        console.warn('[ImmutablePackage] Failed to preprocess wasm; using original bytes:', path, err);
+        return bytes;
+    }
+}
+function cloneToArrayBuffer(u8) {
+    const ab = new ArrayBuffer(u8.byteLength);
+    new Uint8Array(ab).set(u8);
+    return ab;
+}
+function normalizePath(p) {
+    // keep it simple/deterministic: forward slashes, no leading "./"
+    let s = p.replace(/\\/g, '/');
+    while (s.startsWith('./'))
+        s = s.slice(2);
+    while (s.startsWith('/'))
+        s = s.slice(1);
+    // collapse '//' -> '/'
+    s = s.replace(/\/{2,}/g, '/');
+    return s;
+}
+function normalizeSlashes(p) {
+    return p.replace(/\\/g, '/');
+}
+function stripFirstDir(p) {
+    const i = p.indexOf('/');
+    return i === -1 ? p : p.slice(i + 1);
+}
+function isCodeFile(path) {
+    // Mirrors the old framework’s intent: avoid slurping source trees.
+    return /\.(rs|ts|tsx|js|jsx|c|cpp|h|hpp|m|py|java|cs|lock|d|o|toml)$/i.test(path);
+}
+function isTargetRootWasm(relPath) {
+    // EXACTLY:
+    // target/wasm32-unknown-unknown/{debug|release}/<file>.wasm
+    const m = relPath.match(/^target\/wasm32-unknown-unknown\/(debug|release)\/[^/]+\.wasm$/i);
+    if (!m)
+        return { ok: false, isRelease: false };
+    return { ok: true, isRelease: m[1].toLowerCase() === 'release' };
+}
+function shouldIncludePath(relPath) {
+    // Skip obvious junk/heavy dirs
+    if (relPath.startsWith('.git/'))
+        return false;
+    if (relPath.startsWith('node_modules/'))
+        return false;
+    if (relPath.endsWith('.DS_Store'))
+        return false;
+    // IMPORTANT: Ignore ALL of target/ here. We handle the ONE allowed wasm separately.
+    if (relPath.startsWith('target/'))
+        return false;
+    // Skip code/config
+    if (isCodeFile(relPath))
+        return false;
+    return true;
+}
+function shouldSkipDir(relDir) {
+    // relDir is normalized (forward slashes, no leading slash). Usually ends with "/".
+    if (!relDir)
+        return true;
+    // Always skip these entire trees (huge / irrelevant)
+    if (relDir.startsWith('.git/'))
+        return true;
+    if (relDir.startsWith('node_modules/'))
+        return true;
+    // Hard rule: ignore everything in target/ except these directories:
+    // target/
+    // target/wasm32-unknown-unknown/
+    // target/wasm32-unknown-unknown/debug/
+    // target/wasm32-unknown-unknown/release/
+    if (relDir.startsWith('target/')) {
+        if (relDir === 'target/')
+            return false;
+        if (relDir === 'target/wasm32-unknown-unknown/')
+            return false;
+        if (relDir === 'target/wasm32-unknown-unknown/debug/')
+            return false;
+        if (relDir === 'target/wasm32-unknown-unknown/release/')
+            return false;
+        return true; // skip EVERYTHING else under target/
+    }
+    return false;
+}
+function extLower(path) {
+    const idx = path.lastIndexOf('.');
+    return idx >= 0 ? path.slice(idx + 1).toLowerCase() : '';
+}
+function guessMime(ext) {
+    switch (ext) {
+        case 'wasm': return 'application/wasm';
+        case 'json': return 'application/json';
+        case 'txt': return 'text/plain';
+        case 'png': return 'image/png';
+        case 'jpg':
+        case 'jpeg': return 'image/jpeg';
+        case 'gif': return 'image/gif';
+        case 'webp': return 'image/webp';
+        case 'wav': return 'audio/wav';
+        case 'mp3': return 'audio/mpeg';
+        case 'ogg': return 'audio/ogg';
+        default: return undefined;
+    }
+}
+function detectKind(ext) {
+    if (ext === 'wasm')
+        return 'wasm';
+    if (ext === 'json')
+        return 'json';
+    if (ext === 'txt' || ext === 'md')
+        return 'text';
+    if (ext === 'png' || ext === 'jpg' || ext === 'jpeg' || ext === 'gif' || ext === 'webp')
+        return 'image';
+    if (ext === 'wav' || ext === 'mp3' || ext === 'ogg')
+        return 'audio';
+    return 'binary';
+}
+function tryParsePngSize(bytes) {
+    // PNG header parse is deterministic: width/height are big-endian at offsets 16/20 (IHDR data)
+    // Signature: 8 bytes: 89 50 4E 47 0D 0A 1A 0A
+    if (bytes.length < 24)
+        return null;
+    if (bytes[0] !== 0x89 || bytes[1] !== 0x50 || bytes[2] !== 0x4e || bytes[3] !== 0x47 ||
+        bytes[4] !== 0x0d || bytes[5] !== 0x0a || bytes[6] !== 0x1a || bytes[7] !== 0x0a)
+        return null;
+    // chunk type "IHDR" should begin at 12
+    if (bytes[12] !== 0x49 || bytes[13] !== 0x48 || bytes[14] !== 0x44 || bytes[15] !== 0x52)
+        return null;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const w = view.getUint32(16, false);
+    const h = view.getUint32(20, false);
+    if (w === 0 || h === 0)
+        return null;
+    return { w, h };
+}
+function tryParseWavDurationMs(bytes) {
+    // Deterministic WAV header parse (RIFF/WAVE with fmt + data chunks)
+    if (bytes.length < 44)
+        return null;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const tag = (o) => String.fromCharCode(bytes[o], bytes[o + 1], bytes[o + 2], bytes[o + 3]);
+    if (tag(0) !== 'RIFF' || tag(8) !== 'WAVE')
+        return null;
+    let off = 12;
+    let sampleRate = 0;
+    let blockAlign = 0;
+    let dataSize = 0;
+    while (off + 8 <= bytes.length) {
+        const id = tag(off);
+        const size = view.getUint32(off + 4, true);
+        off += 8;
+        if (off + size > bytes.length)
+            break;
+        if (id === 'fmt ') {
+            // PCM fmt chunk
+            // audioFormat u16, numChannels u16, sampleRate u32, byteRate u32, blockAlign u16, bitsPerSample u16
+            if (size >= 16) {
+                sampleRate = view.getUint32(off + 4, true);
+                blockAlign = view.getUint16(off + 12, true);
+            }
+        }
+        else if (id === 'data') {
+            dataSize = size;
+        }
+        off += size;
+        // chunks are word-aligned (pad byte)
+        if (off & 1)
+            off += 1;
+    }
+    if (sampleRate <= 0 || blockAlign <= 0 || dataSize <= 0)
+        return null;
+    const seconds = dataSize / (sampleRate * blockAlign);
+    return Math.round(seconds * 1000);
+}
+function buildManifest(files) {
+    // bombcrate expects a UTF-8 JSON manifest (written into WASM memory during init_end()).
+    // It contains ONLY files (no directories) so there are never any empty folders.
+    const entries = files.map((f) => ({
+        id: f.id,
+        path: f.path,
+        meta: {
+            // Keep key order stable; undefined fields are omitted by JSON.stringify.
+            kind: f.meta.kind,
+            byteLength: f.meta.byteLength,
+            mime: f.meta.mime,
+            audioDurationMs: f.meta.audioDurationMs,
+            imageWidth: f.meta.imageWidth,
+            imageHeight: f.meta.imageHeight,
+        },
+    }));
+    // Stable output (helpful for debugging + deterministic packaging).
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+    const manifest = {
+        version: 1,
+        files: entries,
+    };
+    const text = JSON.stringify(manifest);
+    return new TextEncoder().encode(text);
+}
+async function* walkDir(dir, prefix) {
+    // File System Access API
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const entries = dir.entries?.();
+    for await (const [name, handle] of entries) {
+        if (handle.kind === 'file') {
+            yield { path: prefix + name, handle: handle };
+        }
+        else if (handle.kind === 'directory') {
+            const dirPath = normalizePath(`${prefix}${name}/`);
+            if (shouldSkipDir(dirPath))
+                continue;
+            yield* walkDir(handle, dirPath);
+        }
+    }
+}
+async function pickSingleFileViaInput(accept) {
+    if (typeof document === 'undefined') {
+        throw new Error('File picker requires a browser DOM (document is undefined).');
+    }
+    return await new Promise((resolve, reject) => {
+        const input = document.createElement('input');
+        input.type = 'file';
+        input.accept = accept;
+        input.multiple = false;
+        // Keep it out of sight but in the DOM (Safari can be picky about this).
+        input.style.position = 'fixed';
+        input.style.left = '-9999px';
+        input.style.top = '0';
+        const cleanup = () => {
+            input.onchange = null;
+            input.onerror = null;
+            input.remove();
+        };
+        input.onchange = () => {
+            const file = input.files && input.files[0] ? input.files[0] : null;
+            cleanup();
+            if (!file)
+                reject(new Error('No file selected.'));
+            else
+                resolve(file);
+        };
+        input.onerror = () => {
+            cleanup();
+            reject(new Error('File picker failed.'));
+        };
+        document.body.appendChild(input);
+        input.click();
+    });
+}
+export class ImmutablePackage {
+    constructor(files, wasmId) {
+        this.files = files;
+        this.wasmId = wasmId;
+        this.byId = new Map(files.map((f) => [f.id, f]));
+        this.byPath = new Map(files.map((f) => [f.path, f]));
+    }
+    /** True if we can pick a folder in this browser (either API or webkitdirectory). */
+    static supportsFolderPicker() {
+        const g = globalThis;
+        if (typeof g.showDirectoryPicker === 'function')
+            return true;
+        // webkitdirectory detection
+        if (typeof document !== 'undefined') {
+            const input = document.createElement('input');
+            return ('webkitdirectory' in input) || ('directory' in input);
+        }
+        return false;
+    }
+    /** Safari/Brave-friendly folder picker: <input type="file" webkitdirectory multiple> */
+    static pickFolderViaWebkitInput() {
+        if (typeof document === 'undefined') {
+            throw new Error('pickFolderViaWebkitInput() must be called in a browser.');
+        }
+        return new Promise((resolve, reject) => {
+            const input = document.createElement('input');
+            input.type = 'file';
+            input.multiple = true;
+            // Non-standard but widely supported
+            input.setAttribute('webkitdirectory', '');
+            input.setAttribute('directory', '');
+            // Keep it off-screen but in-DOM (Safari can be picky)
+            input.style.position = 'fixed';
+            input.style.left = '-10000px';
+            input.style.top = '-10000px';
+            document.body.appendChild(input);
+            let done = false;
+            let sawBlur = false;
+            const cleanup = () => {
+                try {
+                    window.removeEventListener('focus', onFocus, true);
+                    window.removeEventListener('blur', onBlur, true);
+                }
+                catch { }
+                input.remove();
+            };
+            const finish = (files) => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                if (!files || files.length === 0) {
+                    reject(new Error('Folder selection canceled.'));
+                }
+                else {
+                    resolve(files);
+                }
+            };
+            input.addEventListener('change', () => {
+                finish(input.files);
+            }, { once: true });
+            const onBlur = () => {
+                sawBlur = true;
+            };
+            const onFocus = () => {
+                // Only run cancel logic if we actually saw the window blur (i.e., picker likely opened).
+                if (!sawBlur)
+                    return;
+                const start = Date.now();
+                const maxWaitMs = 8000; // generous; prevents false cancels
+                const stepMs = 100;
+                const poll = () => {
+                    if (done)
+                        return;
+                    const files = input.files;
+                    if (files && files.length > 0) {
+                        finish(files);
+                        return;
+                    }
+                    if (Date.now() - start >= maxWaitMs) {
+                        finish(null); // treat as cancel
+                        return;
+                    }
+                    setTimeout(poll, stepMs);
+                };
+                // Start polling very soon after focus returns
+                setTimeout(poll, 0);
+            };
+            window.addEventListener('blur', onBlur, true);
+            window.addEventListener('focus', onFocus, true);
+            input.click();
+        });
+    }
+    /**
+     * Build a package from a FileList (e.g. returned by webkitdirectory picker).
+     * This is also handy if you ever add an explicit <input webkitdirectory> in the demo HTML.
+     */
+    static async fromFileList(fileList, options = {}) {
+        const files = [];
+        let nextId = 1;
+        // Collect ONLY root target wasm candidates; do NOT include them yet.
+        const targetWasmCandidates = [];
+        for (const f of Array.from(fileList)) {
+            const raw = f.webkitRelativePath ? String(f.webkitRelativePath) : f.name;
+            let relPath = normalizeSlashes(raw);
+            // Remove the selected folder name prefix so both pickers align
+            relPath = stripFirstDir(relPath);
+            relPath = normalizePath(relPath);
+            if (!relPath)
+                continue;
+            // HARD RULE: ignore everything in target/ except the ONE allowed wasm candidate(s)
+            if (relPath.startsWith('target/')) {
+                const cand = isTargetRootWasm(relPath);
+                if (cand.ok) {
+                    targetWasmCandidates.push({
+                        path: relPath,
+                        file: f,
+                        lastModified: Number.isFinite(f.lastModified) ? f.lastModified : 0,
+                        isRelease: cand.isRelease,
+                    });
+                }
+                continue; // ignore ALL other target files
+            }
+            // Normal non-target filtering
+            if (!shouldIncludePath(relPath))
+                continue;
+            const buf = await f.arrayBuffer();
+            let bytes = new Uint8Array(buf);
+            const ext = extLower(relPath);
+            const kind = detectKind(ext);
+            if (kind === 'wasm') {
+                bytes = await preprocessWasmIfNeeded(relPath, bytes);
+            }
+            const mime = f.type || guessMime(ext);
+            const meta = {
+                kind,
+                byteLength: bytes.byteLength,
+                mime,
+            };
+            if (kind === 'image' && ext === 'png') {
+                const sz = tryParsePngSize(bytes);
+                if (sz) {
+                    meta.imageWidth = sz.w;
+                    meta.imageHeight = sz.h;
+                }
+            }
+            if (kind === 'audio' && ext === 'wav') {
+                const dur = tryParseWavDurationMs(bytes);
+                if (dur != null)
+                    meta.audioDurationMs = dur;
+            }
+            const id = nextId++;
+            files.push({ id, path: relPath, bytes, meta });
+        }
+        if (files.length === 0 && targetWasmCandidates.length === 0) {
+            throw new Error('Selected folder contains no files.');
+        }
+        // Decide which wasm becomes the package entrypoint
+        let wasmId = 0;
+        if (options.wasmPath) {
+            const wanted = normalizePath(options.wasmPath);
+            const hit = targetWasmCandidates.find((c) => c.path === wanted);
+            if (hit) {
+                const ab = await hit.file.arrayBuffer();
+                let bytes = new Uint8Array(ab);
+                // preprocess ONLY this one file
+                bytes = await preprocessWasmIfNeeded(hit.path, bytes);
+                const id = nextId++;
+                files.push({
+                    id,
+                    path: hit.path,
+                    bytes,
+                    meta: {
+                        kind: 'wasm',
+                        byteLength: bytes.byteLength,
+                        mime: hit.file.type || guessMime('wasm') || 'application/wasm',
+                    },
+                });
+                wasmId = id;
+            }
+            else {
+                // Or wanted might be a non-target file we already included
+                const existing = files.find((x) => x.path === wanted);
+                if (!existing)
+                    throw new Error(`wasmPath not found in folder: ${wanted}`);
+                if (existing.meta.kind !== 'wasm')
+                    throw new Error(`wasmPath is not a .wasm file: ${wanted}`);
+                wasmId = existing.id;
+            }
+        }
+        else {
+            // Default selection: choose ONE target wasm if present
+            if (targetWasmCandidates.length > 0) {
+                targetWasmCandidates.sort((a, b) => {
+                    if (b.lastModified !== a.lastModified)
+                        return b.lastModified - a.lastModified;
+                    if (a.isRelease !== b.isRelease)
+                        return a.isRelease ? -1 : 1; // prefer release
+                    return a.path.localeCompare(b.path);
+                });
+                const chosen = targetWasmCandidates[0];
+                const ab = await chosen.file.arrayBuffer();
+                let bytes = new Uint8Array(ab);
+                // preprocess ONLY this one file
+                bytes = await preprocessWasmIfNeeded(chosen.path, bytes);
+                const id = nextId++;
+                files.push({
+                    id,
+                    path: chosen.path,
+                    bytes,
+                    meta: {
+                        kind: 'wasm',
+                        byteLength: bytes.byteLength,
+                        mime: chosen.file.type || guessMime('wasm') || 'application/wasm',
+                    },
+                });
+                wasmId = id;
+            }
+            else {
+                // fallback: if no target wasm candidates were found, pick the first wasm already included
+                const firstWasm = files.find((x) => x.meta.kind === 'wasm');
+                if (!firstWasm) {
+                    throw new Error('No target wasm found. Expected one of:\n' +
+                        '- target/wasm32-unknown-unknown/release/<name>.wasm\n' +
+                        '- target/wasm32-unknown-unknown/debug/<name>.wasm');
+                }
+                wasmId = firstWasm.id;
+            }
+        }
+        // Add manifest as id=-1 (JSON)
+        const manifestBytes = buildManifest(files);
+        files.push({
+            id: -1,
+            path: '__manifest__',
+            bytes: manifestBytes,
+            meta: { kind: 'json', byteLength: manifestBytes.byteLength, mime: 'application/json' },
+        });
+        return new ImmutablePackage(files, wasmId);
+    }
+    listWasmFiles() {
+        return this.files.filter((f) => f.meta.kind === 'wasm' && f.id !== -1);
+    }
+    getById(id) {
+        return this.byId.get(id | 0);
+    }
+    getByPath(path) {
+        return this.byPath.get(normalizePath(path));
+    }
+    getBytesById(id) {
+        const f = this.getById(id);
+        return f ? f.bytes : null;
+    }
+    toWorkerPayload(opts = {}) {
+        const transfer = opts.transfer ?? true;
+        const transferables = [];
+        const files = this.files.map((f) => {
+            // IMPORTANT: ensure this is a real ArrayBuffer (not ArrayBufferLike)
+            // and contains exactly the bytes (no offsets).
+            const bytes = cloneToArrayBuffer(f.bytes);
+            if (transfer)
+                transferables.push(bytes);
+            return { id: f.id, path: f.path, bytes, meta: f.meta };
+        });
+        const wasmId = (opts.wasmIdOverride ?? this.wasmId) | 0;
+        return { pkg: { wasmId, files }, transferables };
+    }
+    static async fromDirectoryPicker(options = {}) {
+        const g = globalThis;
+        if (typeof g.showDirectoryPicker === 'function') {
+            let dir = null;
+            try {
+                dir = await g.showDirectoryPicker();
+            }
+            catch (e) {
+                // If user cancels, surface cancel (don’t fallback)
+                if (e?.name === 'AbortError')
+                    throw new Error('Folder selection canceled.');
+                console.warn('[ImmutablePackage] showDirectoryPicker failed, falling back to webkitdirectory:', e?.name ?? e);
+                dir = null;
+            }
+            if (dir) {
+                // Optional permission request (some browsers are finicky)
+                try {
+                    const req = dir.requestPermission;
+                    if (typeof req === 'function') {
+                        const perm = await req.call(dir, { mode: 'read' });
+                        if (perm === 'denied')
+                            throw new Error('Folder permission denied.');
+                    }
+                }
+                catch (e) {
+                    // If permission check fails, still try reading; let errors surface.
+                }
+                // IMPORTANT: if this fails, do NOT fallback (it hides the bug and triggers webkit issues).
+                return await ImmutablePackage.fromDirectoryHandle(dir, options);
+            }
+        }
+        const list = await this.pickFolderViaWebkitInput();
+        return await this.fromFileList(list, options);
+    }
+    static async fromWasmFilePicker() {
+        let file;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wAny = globalThis;
+        if (typeof wAny.showOpenFilePicker === 'function') {
+            const [handle] = await wAny.showOpenFilePicker({
+                multiple: false,
+                excludeAcceptAllOption: true,
+                types: [
+                    {
+                        description: 'WebAssembly Module',
+                        accept: {
+                            'application/wasm': ['.wasm'],
+                        },
+                    },
+                ],
+            });
+            file = await handle.getFile();
+        }
+        else {
+            file = await pickSingleFileViaInput('.wasm');
+        }
+        const ab = await file.arrayBuffer();
+        let bytes = new Uint8Array(ab);
+        const norm = normalizePath(file.name);
+        const ext = extLower(norm);
+        const kind = detectKind(ext);
+        if (kind !== 'wasm')
+            throw new Error('Selected file is not a .wasm file.');
+        bytes = await preprocessWasmIfNeeded(norm, bytes);
+        const meta = {
+            kind,
+            byteLength: bytes.byteLength,
+            mime: file.type || guessMime(ext),
+        };
+        const pkgFile = {
+            id: 1,
+            path: norm,
+            bytes,
+            meta,
+        };
+        const files = [pkgFile];
+        // Add manifest as id=-1 (JSON)
+        const manifestBytes = buildManifest(files);
+        files.push({
+            id: -1,
+            path: '__manifest__',
+            bytes: manifestBytes,
+            meta: { kind: 'json', byteLength: manifestBytes.byteLength, mime: 'application/json' },
+        });
+        return new ImmutablePackage(files, pkgFile.id);
+    }
+    static async fromDirectoryHandle(dir, options = {}) {
+        const files = [];
+        let nextId = 1;
+        const targetWasmCandidates = [];
+        for await (const { path, handle } of walkDir(dir, '')) {
+            const norm = normalizePath(path);
+            if (!norm)
+                continue;
+            // HARD RULE: ignore all of target except root wasm candidates
+            if (norm.startsWith('target/')) {
+                const cand = isTargetRootWasm(norm);
+                if (cand.ok) {
+                    // getFile() just to read lastModified (cheap; bytes not read)
+                    const f = await handle.getFile();
+                    targetWasmCandidates.push({
+                        path: norm,
+                        handle,
+                        lastModified: Number.isFinite(f.lastModified) ? f.lastModified : 0,
+                        isRelease: cand.isRelease,
+                    });
+                }
+                continue;
+            }
+            if (!shouldIncludePath(norm))
+                continue;
+            const ext = extLower(norm);
+            const kind = detectKind(ext);
+            const file = await handle.getFile();
+            const ab = await file.arrayBuffer();
+            let bytes = new Uint8Array(ab);
+            if (kind === 'wasm') {
+                bytes = await preprocessWasmIfNeeded(norm, bytes);
+            }
+            const mime = file.type || guessMime(ext);
+            const meta = {
+                kind,
+                byteLength: bytes.byteLength,
+                mime,
+            };
+            if (kind === 'image' && ext === 'png') {
+                const sz = tryParsePngSize(bytes);
+                if (sz) {
+                    meta.imageWidth = sz.w;
+                    meta.imageHeight = sz.h;
+                }
+            }
+            if (kind === 'audio' && ext === 'wav') {
+                const dur = tryParseWavDurationMs(bytes);
+                if (dur != null)
+                    meta.audioDurationMs = dur;
+            }
+            const id = nextId++;
+            files.push({ id, path: norm, bytes, meta });
+        }
+        if (files.length === 0 && targetWasmCandidates.length === 0) {
+            throw new Error('Selected folder contains no files.');
+        }
+        // Choose wasm
+        let wasmId = 0;
+        if (options.wasmPath) {
+            const wanted = normalizePath(options.wasmPath);
+            const hit = targetWasmCandidates.find((c) => c.path === wanted);
+            if (hit) {
+                const f = await hit.handle.getFile();
+                const ab = await f.arrayBuffer();
+                let bytes = new Uint8Array(ab);
+                bytes = await preprocessWasmIfNeeded(hit.path, bytes);
+                const id = nextId++;
+                files.push({
+                    id,
+                    path: hit.path,
+                    bytes,
+                    meta: { kind: 'wasm', byteLength: bytes.byteLength, mime: f.type || guessMime('wasm') || 'application/wasm' },
+                });
+                wasmId = id;
+            }
+            else {
+                const existing = files.find((x) => x.path === wanted);
+                if (!existing)
+                    throw new Error(`wasmPath not found in folder: ${wanted}`);
+                if (existing.meta.kind !== 'wasm')
+                    throw new Error(`wasmPath is not a .wasm file: ${wanted}`);
+                wasmId = existing.id;
+            }
+        }
+        else {
+            if (targetWasmCandidates.length > 0) {
+                targetWasmCandidates.sort((a, b) => {
+                    if (b.lastModified !== a.lastModified)
+                        return b.lastModified - a.lastModified;
+                    if (a.isRelease !== b.isRelease)
+                        return a.isRelease ? -1 : 1;
+                    return a.path.localeCompare(b.path);
+                });
+                const chosen = targetWasmCandidates[0];
+                const f = await chosen.handle.getFile();
+                const ab = await f.arrayBuffer();
+                let bytes = new Uint8Array(ab);
+                bytes = await preprocessWasmIfNeeded(chosen.path, bytes);
+                const id = nextId++;
+                files.push({
+                    id,
+                    path: chosen.path,
+                    bytes,
+                    meta: { kind: 'wasm', byteLength: bytes.byteLength, mime: f.type || guessMime('wasm') || 'application/wasm' },
+                });
+                wasmId = id;
+            }
+            else {
+                const firstWasm = files.find((x) => x.meta.kind === 'wasm');
+                if (!firstWasm) {
+                    throw new Error('No target wasm found. Expected one of:\n' +
+                        '- target/wasm32-unknown-unknown/release/<name>.wasm\n' +
+                        '- target/wasm32-unknown-unknown/debug/<name>.wasm');
+                }
+                wasmId = firstWasm.id;
+            }
+        }
+        // Add manifest as id=-1 (JSON)
+        const manifestBytes = buildManifest(files);
+        files.push({
+            id: -1,
+            path: '__manifest__',
+            bytes: manifestBytes,
+            meta: { kind: 'json', byteLength: manifestBytes.byteLength, mime: 'application/json' },
+        });
+        return new ImmutablePackage(files, wasmId);
+    }
+}
+//# sourceMappingURL=package.js.map