// Minimal browser WASI shim. Loaded by index.html, which sets
// window.CRAFTER_WASM_URL before this script runs so a single runtime.js
// can serve any output name. Most syscalls return 0 — enough to host a
// hello-world that uses fd_write (stdout) and the args/environ probes
// libc invokes during startup. Extend as needed.

const textEncoder = new TextEncoder();

// ─── Two VFS roots ─────────────────────────────────────────────────────
//   fd=3  ⟶  read-only baked layer at "/". Populated from files.json at
//            startup, keyed by basename — the bin-dir layout `cfg.assets`
//            produces is flat enough that basename collapse doesn't
//            collide for legitimate assets. Writes are rejected.
//   fd=4  ⟶  read/write persistent layer at "/persistent". Backed by OPFS
//            (Origin Private File System), keyed by relative path so
//            nested directories work. The wasm sees an in-memory map
//            (writes are synchronous from its POV); a background task
//            mirrors dirty entries back to OPFS so they survive reload.
//
// wasi-libc walks preopens starting at fd=3 and resolves every open()
// against the longest matching preopen. "/persistent/foo.json" hits fd=4
// with relpath "foo.json"; "/Inter.ttf" hits fd=3 with relpath "Inter.ttf".

const readonlyVfs   = new Map();   // basename → Uint8Array (immutable)
const persistentVfs = new Map();   // relpath  → Uint8Array (mutable)
// Paths the wasm has mkdir'd. Our backing store is flat-keyed so dirs
// don't otherwise exist on their own — but libstdc++'s
// `create_directories` mkdir's, then re-stats each component, and
// expects the stat to report "directory". Tracking explicit mkdir'd
// paths here keeps that loop convergent.
const persistentDirs = new Set();

const ROOTS = {
    3: { kind: "ro", map: readonlyVfs,   name: "/" },
    4: { kind: "rw", map: persistentVfs, name: "/persistent" },
};

function resolveKey(root, raw) {
    if (root.kind === "ro") {
        // Read-only baked layer: paths collapse to basename so the C++
        // side can use "assets/foo.ctex" or "./foo.ctex" interchangeably.
        return raw.split(/[\\/]/).filter(Boolean).pop() || raw;
    }
    // Persistent layer: keep the relative path so nested entries mirror
    // OPFS's directory structure.
    let key = raw.replace(/\\/g, "/");
    while (key.startsWith("./")) key = key.slice(2);
    while (key.startsWith("/"))  key = key.slice(1);
    return key;
}

// ─── OPFS mirror for the persistent layer ──────────────────────────────
let opfsRoot = null;
const dirtyPaths = new Set();
let flushTimer = null;
const FLUSH_DEBOUNCE_MS = 750;

async function opfsResolveDir(parts, create) {
    if (!opfsRoot) return null;
    let dir = opfsRoot;
    for (const part of parts) {
        if (!part) continue;
        dir = await dir.getDirectoryHandle(part, { create });
    }
    return dir;
}

async function opfsHydrate() {
    if (!navigator.storage || !navigator.storage.getDirectory) {
        console.warn("[wasi] OPFS unavailable — persistent writes will not survive reload");
        return;
    }
    try {
        opfsRoot = await navigator.storage.getDirectory();
    } catch (e) {
        console.warn("[wasi] OPFS getDirectory failed:", e?.message);
        return;
    }
    async function walk(dir, prefix) {
        for await (const [name, handle] of dir.entries()) {
            const full = prefix ? `${prefix}/${name}` : name;
            if (handle.kind === "file") {
                try {
                    const file = await handle.getFile();
                    persistentVfs.set(full, new Uint8Array(await file.arrayBuffer()));
                } catch (e) {
                    console.warn(`[wasi] OPFS read failed for ${full}:`, e?.message);
                }
            } else if (handle.kind === "directory") {
                await walk(handle, full);
            }
        }
    }
    await walk(opfsRoot, "");
}

async function opfsFlushOne(path) {
    if (!opfsRoot) return;
    const parts = path.split("/").filter(Boolean);
    if (parts.length === 0) return;
    const data = persistentVfs.get(path);
    if (data === undefined) {
        // Removed entry — delete from OPFS, walking parents.
        try {
            const parent = await opfsResolveDir(parts.slice(0, -1), false);
            await parent.removeEntry(parts[parts.length - 1]);
        } catch (e) {
            // Missing entry is fine; other errors get reported.
            if (e && e.name !== "NotFoundError") {
                console.warn(`[wasi] OPFS remove failed for ${path}:`, e?.message);
            }
        }
        return;
    }
    try {
        const dir = await opfsResolveDir(parts.slice(0, -1), true);
        const fh = await dir.getFileHandle(parts[parts.length - 1], { create: true });
        const w  = await fh.createWritable();
        await w.write(data);
        await w.close();
    } catch (e) {
        console.warn(`[wasi] OPFS write failed for ${path}:`, e?.message);
    }
}

async function opfsFlushAll() {
    if (!opfsRoot) return;
    const batch = Array.from(dirtyPaths);
    dirtyPaths.clear();
    for (const path of batch) {
        await opfsFlushOne(path);
    }
}

function scheduleFlush() {
    if (flushTimer !== null) return;
    flushTimer = setTimeout(() => {
        flushTimer = null;
        opfsFlushAll();
    }, FLUSH_DEBOUNCE_MS);
}

function markDirty(path) {
    dirtyPaths.add(path);
    scheduleFlush();
}

class Wasi {
    #encodedStdin;
    #envEncodedStrings;
    #argEncodedStrings;
    instance;
    #fdTable;
    #nextFd;
    #decoder;

    constructor({ env, stdin, args }) {
        this.#encodedStdin = textEncoder.encode(stdin);
        const envStrings = Object.entries(env).map(([k, v]) => `${k}=${v}`);
        this.#envEncodedStrings = envStrings.map(s => textEncoder.encode(s + "\0"));
        this.#argEncodedStrings = args.map(s => textEncoder.encode(s + "\0"));
        this.#fdTable = new Map();
        this.#nextFd = 100;            // stay clear of stdio + preopens
        this.#decoder = new TextDecoder();
        this.bind();
    }

    bind() {
        // wasi imports are looked up as plain function references at
        // instantiate time, so any method that touches `this` MUST be
        // explicitly bound here. Anything purely no-op (returning 0) can
        // stay unbound.
        const m = [
            "args_get", "args_sizes_get",
            "environ_get", "environ_sizes_get",
            "fd_read", "fd_write", "fd_pwrite",
            "fd_close", "fd_seek", "fd_tell",
            "fd_filestat_get", "fd_fdstat_get",
            "fd_prestat_get", "fd_prestat_dir_name",
            "path_open", "path_create_directory", "path_remove_directory",
            "path_unlink_file", "path_rename", "path_filestat_get",
        ];
        for (const name of m) this[name] = this[name].bind(this);
    }

    args_sizes_get(argCountPtr, argBufferSizePtr) {
        const argByteLength = this.#argEncodedStrings.reduce((sum, val) => sum + val.byteLength, 0);
        const countPointerBuffer = new Uint32Array(this.instance.exports.memory.buffer, argCountPtr, 1);
        const sizePointerBuffer = new Uint32Array(this.instance.exports.memory.buffer, argBufferSizePtr, 1);
        countPointerBuffer[0] = this.#argEncodedStrings.length;
        sizePointerBuffer[0] = argByteLength;
        return 0;
    }
    args_get(argsPtr, argBufferPtr) {
        const argsByteLength = this.#argEncodedStrings.reduce((sum, val) => sum + val.byteLength, 0);
        const argsPointerBuffer = new Uint32Array(this.instance.exports.memory.buffer, argsPtr, this.#argEncodedStrings.length);
        const argsBuffer = new Uint8Array(this.instance.exports.memory.buffer, argBufferPtr, argsByteLength);

        let pointerOffset = 0;
        for (let i = 0; i < this.#argEncodedStrings.length; i++) {
            argsPointerBuffer[i] = argBufferPtr + pointerOffset;
            argsBuffer.set(this.#argEncodedStrings[i], pointerOffset);
            pointerOffset += this.#argEncodedStrings[i].byteLength;
        }
        return 0;
    }
    fd_write(fd, iovsPtr, iovsLength, bytesWrittenPtr) {
        const dv   = new DataView(this.instance.exports.memory.buffer);
        const iovs = new Uint32Array(this.instance.exports.memory.buffer, iovsPtr, iovsLength * 2);
        if (fd === 1 || fd === 2) {
            let text = "";
            let totalBytesWritten = 0;
            const decoder = new TextDecoder();
            for (let i = 0; i < iovsLength * 2; i += 2) {
                const offset = iovs[i];
                const length = iovs[i + 1];
                text += decoder.decode(new Int8Array(this.instance.exports.memory.buffer, offset, length));
                totalBytesWritten += length;
            }
            dv.setInt32(bytesWrittenPtr, totalBytesWritten, true);
            (fd === 2 ? console.error : console.log)(text);
            return 0;
        }

        const entry = this.#fdTable.get(fd);
        if (!entry) {
            dv.setInt32(bytesWrittenPtr, 0, true);
            return 8; // EBADF
        }
        const root = ROOTS[entry.rootFd];
        if (!root || root.kind !== "rw") {
            dv.setInt32(bytesWrittenPtr, 0, true);
            return 76; // EROFS — close enough; libc surfaces this as "no permission"
        }

        // Sum iov lengths so we can grow the entry once.
        let total = 0;
        for (let i = 0; i < iovsLength * 2; i += 2) total += iovs[i + 1];

        let data = root.map.get(entry.name) ?? new Uint8Array(0);
        const end = entry.offset + total;
        if (data.byteLength < end) {
            const grown = new Uint8Array(end);
            grown.set(data, 0);
            data = grown;
            root.map.set(entry.name, data);
        }

        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        let written = 0;
        for (let i = 0; i < iovsLength * 2; i += 2) {
            const offset = iovs[i];
            const length = iovs[i + 1];
            data.set(memory.subarray(offset, offset + length), entry.offset + written);
            written += length;
        }
        entry.offset += written;
        dv.setInt32(bytesWrittenPtr, written, true);
        markDirty(entry.name);
        return 0;
    }
    fd_pwrite(fd, iovsPtr, iovsLength, offsetArg, bytesWrittenPtr) {
        // pwrite is positioned write — same as fd_write but the seek pos
        // isn't advanced. We just temporarily override entry.offset.
        const entry = this.#fdTable.get(fd);
        if (!entry) {
            new DataView(this.instance.exports.memory.buffer)
                .setInt32(bytesWrittenPtr, 0, true);
            return 8;
        }
        const saved = entry.offset;
        entry.offset = typeof offsetArg === "bigint" ? Number(offsetArg) : Number(offsetArg);
        const rc = this.fd_write(fd, iovsPtr, iovsLength, bytesWrittenPtr);
        entry.offset = saved;
        return rc;
    }
    fd_read(fd, iovsPtr, iovsLength, bytesReadPtr) {
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const iovs = new Uint32Array(this.instance.exports.memory.buffer, iovsPtr, iovsLength * 2);
        const dataView = new DataView(this.instance.exports.memory.buffer);
        let totalBytesRead = 0;
        if (fd === 0) {
            for (let i = 0; i < iovsLength * 2; i += 2) {
                const offset = iovs[i];
                const length = iovs[i + 1];
                const chunk = this.#encodedStdin.slice(0, length);
                this.#encodedStdin = this.#encodedStdin.slice(length);
                memory.set(chunk, offset);
                totalBytesRead += chunk.byteLength;
                if (this.#encodedStdin.length === 0) break;
            }
            dataView.setInt32(bytesReadPtr, totalBytesRead, true);
            return 0;
        }
        const entry = this.#fdTable.get(fd);
        if (!entry) {
            dataView.setInt32(bytesReadPtr, 0, true);
            return 8; // EBADF
        }
        const root = ROOTS[entry.rootFd];
        const file = root ? root.map.get(entry.name) : undefined;
        if (!file) {
            dataView.setInt32(bytesReadPtr, 0, true);
            return 0; // EOF
        }
        for (let i = 0; i < iovsLength * 2; i += 2) {
            const offset = iovs[i];
            const length = iovs[i + 1];
            const remaining = file.byteLength - entry.offset;
            if (remaining <= 0) break;
            const n = Math.min(length, remaining);
            memory.set(file.subarray(entry.offset, entry.offset + n), offset);
            entry.offset += n;
            totalBytesRead += n;
            if (n < length) break;
        }
        dataView.setInt32(bytesReadPtr, totalBytesRead, true);
        return 0;
    }
    fd_advise() { return 0; }
    fd_close(fd) {
        this.#fdTable.delete(fd);
        return 0;
    }
    fd_fdstat_get(fd, statPtr) {
        // 24 bytes: filetype(1) + flags(2) + padding + rights_base(8) + rights_inheriting(8).
        const dv = new DataView(this.instance.exports.memory.buffer);
        let filetype;
        if (ROOTS[fd])              filetype = 3; // directory — preopen mount
        else if (this.#fdTable.has(fd)) filetype = 4; // regular_file
        else                        filetype = 0;
        dv.setUint8(statPtr + 0, filetype);
        dv.setUint16(statPtr + 2, 0, true);
        dv.setBigUint64(statPtr + 8,  0xFFFFFFFFFFFFFFFFn, true);
        dv.setBigUint64(statPtr + 16, 0xFFFFFFFFFFFFFFFFn, true);
        return 0;
    }
    // wasi-libc walks preopens starting at fd=3 until fd_prestat_get returns
    // EBADF, then resolves every relative open against one of the discovered
    // dirs. Two preopens: fd=3 ("/") for baked assets, fd=4 ("/persistent")
    // for OPFS-backed mutable state.
    fd_prestat_get(fd, prestatPtr) {
        const dv = new DataView(this.instance.exports.memory.buffer);
        const root = ROOTS[fd];
        if (!root) return 8; // EBADF — terminates the walk
        // prestat_t: tag(u8) + padding to 4 + u.dir.pr_name_len(u32). 8 bytes.
        dv.setUint8(prestatPtr + 0, 0);                            // tag = preopentype_dir
        dv.setUint32(prestatPtr + 4, root.name.length, true);
        return 0;
    }
    fd_prestat_dir_name(fd, pathPtr, pathLen) {
        const root = ROOTS[fd];
        if (!root) return 8;
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const name = textEncoder.encode(root.name);
        memory.set(name.subarray(0, Math.min(name.byteLength, pathLen)), pathPtr);
        return 0;
    }
    clock_res_get() { return 0; }
    clock_time_get() { return 0; }
    fd_seek(fd, offsetLow, whence, newOffsetPtr) {
        // offsetLow is a BigInt under wasi-snapshot-preview1's two-i32 ABI?
        // No — wasi-snapshot-preview1 fd_seek's signature is (fd, filedelta:i64,
        // whence:u8, newoffset:ptr<filesize>). JS receives the i64 as BigInt.
        const entry = this.#fdTable.get(fd);
        const dv = new DataView(this.instance.exports.memory.buffer);
        if (!entry) {
            dv.setBigUint64(newOffsetPtr, 0n, true);
            return 8;
        }
        const delta = typeof offsetLow === "bigint" ? Number(offsetLow) : Number(offsetLow);
        const root = ROOTS[entry.rootFd];
        const file = root ? root.map.get(entry.name) : undefined;
        const size = file ? file.byteLength : 0;
        let newOff;
        switch (whence) {
            case 0: newOff = delta; break;                       // SEEK_SET
            case 1: newOff = entry.offset + delta; break;        // SEEK_CUR
            case 2: newOff = size + delta; break;                // SEEK_END
            default: return 28;                                  // EINVAL
        }
        if (newOff < 0) newOff = 0;
        // Writeable fds may seek past EOF (the next write extends the
        // backing buffer); read-only fds clamp to EOF.
        if (!root || root.kind !== "rw") {
            if (newOff > size) newOff = size;
        }
        entry.offset = newOff;
        dv.setBigUint64(newOffsetPtr, BigInt(newOff), true);
        return 0;
    }
    fd_tell(fd, offsetPtr) {
        const entry = this.#fdTable.get(fd);
        const dv = new DataView(this.instance.exports.memory.buffer);
        if (!entry) { dv.setBigUint64(offsetPtr, 0n, true); return 8; }
        dv.setBigUint64(offsetPtr, BigInt(entry.offset), true);
        return 0;
    }
    fd_allocate() { return 0; }
    fd_datasync() { return 0; }
    fd_fdstat_set_flags() { return 0; }
    fd_fdstat_set_rights() { return 0; }
    fd_filestat_get(fd, statPtr) {
        // Layout: dev(8) ino(8) filetype(1) +pad nlink(8) size(8) atim(8) mtim(8) ctim(8) = 64 bytes.
        const dv = new DataView(this.instance.exports.memory.buffer);
        let filetype = 4;          // regular_file (default)
        let size = 0;
        if (ROOTS[fd]) {
            filetype = 3;          // directory — preopen mount itself
        } else {
            const entry = this.#fdTable.get(fd);
            if (!entry) return 8;
            const root = ROOTS[entry.rootFd];
            const file = root ? root.map.get(entry.name) : undefined;
            size = file ? file.byteLength : 0;
        }
        dv.setBigUint64(statPtr + 0,  0n, true);
        dv.setBigUint64(statPtr + 8,  0n, true);
        dv.setUint8(statPtr + 16, filetype);
        dv.setBigUint64(statPtr + 24, 1n, true);
        dv.setBigUint64(statPtr + 32, BigInt(size), true);
        dv.setBigUint64(statPtr + 40, 0n, true);
        dv.setBigUint64(statPtr + 48, 0n, true);
        dv.setBigUint64(statPtr + 56, 0n, true);
        return 0;
    }
    fd_filestat_set_size() { return 0; }
    fd_filestat_set_times() { return 0; }
    fd_pread() { return 0; }
    fd_readdir() { return 0; }
    fd_renumber() { return 0; }
    fd_sync() { return 0; }
    path_filestat_get(dirfd, _dirflags, pathPtr, pathLen, statPtr) {
        const root = ROOTS[dirfd];
        if (!root) return 8;
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const raw = this.#decoder.decode(memory.subarray(pathPtr, pathPtr + pathLen));
        const key = resolveKey(root, raw);
        const file = root.map.get(key);
        const dv = new DataView(this.instance.exports.memory.buffer);

        // Resolve filetype: 4 = regular_file, 3 = directory. The
        // preopen mount itself (empty key) is always a directory. Any
        // key that is a prefix of another key acts as a directory too
        // — `std::filesystem::create_directories` walks parent
        // components and stats each one, so reporting them as dirs
        // keeps libc happy even though our backing store is flat-keyed.
        let filetype;
        let size = 0n;
        if (file !== undefined) {
            filetype = 4;
            size = BigInt(file.byteLength);
        } else if (key === "" || persistentDirs.has(key)) {
            filetype = 3;
        } else {
            const prefix = key + "/";
            let isDir = false;
            for (const k of root.map.keys()) {
                if (k.startsWith(prefix)) { isDir = true; break; }
            }
            if (!isDir) return 44; // ENOENT
            filetype = 3;
        }

        dv.setBigUint64(statPtr + 0,  0n, true);
        dv.setBigUint64(statPtr + 8,  0n, true);
        dv.setUint8(statPtr + 16, filetype);
        dv.setBigUint64(statPtr + 24, 1n, true);
        dv.setBigUint64(statPtr + 32, size, true);
        dv.setBigUint64(statPtr + 40, 0n, true);
        dv.setBigUint64(statPtr + 48, 0n, true);
        dv.setBigUint64(statPtr + 56, 0n, true);
        return 0;
    }
    path_create_directory(dirfd, pathPtr, pathLen) {
        const root = ROOTS[dirfd];
        if (!root) return 8;
        if (root.kind !== "rw") return 76;
        // Flat-keyed Map: directories don't need to be "created" for
        // files to exist under them. Track the path in persistentDirs
        // so a subsequent path_filestat_get reports it as a directory
        // — that's what libstdc++'s create_directories looks for to
        // confirm the mkdir landed.
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const raw = this.#decoder.decode(memory.subarray(pathPtr, pathPtr + pathLen));
        const key = resolveKey(root, raw);
        if (key) persistentDirs.add(key);
        return 0;
    }
    path_remove_directory(dirfd, pathPtr, pathLen) {
        const root = ROOTS[dirfd];
        if (!root || root.kind !== "rw") return 8;
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const raw = this.#decoder.decode(memory.subarray(pathPtr, pathPtr + pathLen));
        const key = resolveKey(root, raw);
        // Delete every entry under this prefix and mark them for OPFS removal.
        const prefix = key.endsWith("/") ? key : key + "/";
        for (const k of [...root.map.keys()]) {
            if (k === key || k.startsWith(prefix)) {
                root.map.delete(k);
                markDirty(k);
            }
        }
        return 0;
    }
    path_unlink_file(dirfd, pathPtr, pathLen) {
        const root = ROOTS[dirfd];
        if (!root || root.kind !== "rw") return 8;
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const raw = this.#decoder.decode(memory.subarray(pathPtr, pathPtr + pathLen));
        const key = resolveKey(root, raw);
        if (!root.map.has(key)) return 44; // ENOENT
        root.map.delete(key);
        markDirty(key);
        return 0;
    }
    path_rename(oldDirfd, oldPathPtr, oldPathLen,
                newDirfd, newPathPtr, newPathLen) {
        const oldRoot = ROOTS[oldDirfd];
        const newRoot = ROOTS[newDirfd];
        if (!oldRoot || !newRoot) return 8;
        if (oldRoot.kind !== "rw" || newRoot.kind !== "rw") return 76;
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const oldRaw = this.#decoder.decode(memory.subarray(oldPathPtr, oldPathPtr + oldPathLen));
        const newRaw = this.#decoder.decode(memory.subarray(newPathPtr, newPathPtr + newPathLen));
        const oldKey = resolveKey(oldRoot, oldRaw);
        const newKey = resolveKey(newRoot, newRaw);
        const data = oldRoot.map.get(oldKey);
        if (data === undefined) return 44;
        oldRoot.map.delete(oldKey);
        newRoot.map.set(newKey, data);
        markDirty(oldKey);
        markDirty(newKey);
        return 0;
    }
    path_open(dirfd, _dirflags, pathPtr, pathLen, oflags, _rightsBase, _rightsInh, _fdflags, openedFdPtr) {
        const memory = new Uint8Array(this.instance.exports.memory.buffer);
        const dv = new DataView(this.instance.exports.memory.buffer);
        const root = ROOTS[dirfd];
        if (!root) {
            dv.setInt32(openedFdPtr, -1, true);
            return 8; // EBADF
        }
        const raw = this.#decoder.decode(memory.subarray(pathPtr, pathPtr + pathLen));
        const key = resolveKey(root, raw);

        const O_CREAT = 0x1;
        const O_TRUNC = 0x8;
        const create  = (oflags & O_CREAT) !== 0;
        const trunc   = (oflags & O_TRUNC) !== 0;

        let present = root.map.has(key);
        if (!present) {
            if (!create || root.kind !== "rw") {
                dv.setInt32(openedFdPtr, -1, true);
                return 44; // ENOENT
            }
            root.map.set(key, new Uint8Array(0));
            markDirty(key);
            present = true;
        } else if (trunc && root.kind === "rw") {
            root.map.set(key, new Uint8Array(0));
            markDirty(key);
        }

        const fd = this.#nextFd++;
        this.#fdTable.set(fd, { rootFd: dirfd, name: key, offset: 0 });
        dv.setInt32(openedFdPtr, fd, true);
        return 0;
    }
    path_readlink() { return 0; }
    path_symlink() { return 0; }
    path_link() { return 0; }
    path_filestat_set_times() { return 0; }
    poll_oneoff() { return 0; }
    sched_yield() { return 0; }
    random_get() { return 0; }
    sock_accept() { return 0; }
    sock_recv() { return 0; }
    sock_send() { return 0; }
    sock_shutdown() { return 0; }
    environ_get(environPtr, environBufferPtr) {
        const envByteLength = this.#envEncodedStrings.reduce((sum, val) => sum + val.byteLength, 0);
        const environsPointerBuffer = new Uint32Array(this.instance.exports.memory.buffer, environPtr, this.#envEncodedStrings.length);
        const environsBuffer = new Uint8Array(this.instance.exports.memory.buffer, environBufferPtr, envByteLength);

        let pointerOffset = 0;
        for (let i = 0; i < this.#envEncodedStrings.length; i++) {
            environsPointerBuffer[i] = environBufferPtr + pointerOffset;
            environsBuffer.set(this.#envEncodedStrings[i], pointerOffset);
            pointerOffset += this.#envEncodedStrings[i].byteLength;
        }
        return 0;
    }
    environ_sizes_get(environCountPtr, environBufferSizePtr) {
        const envByteLength = this.#envEncodedStrings.reduce((sum, val) => sum + val.byteLength, 0);
        const countPointerBuffer = new Uint32Array(this.instance.exports.memory.buffer, environCountPtr, 1);
        const sizePointerBuffer = new Uint32Array(this.instance.exports.memory.buffer, environBufferSizePtr, 1);
        countPointerBuffer[0] = this.#envEncodedStrings.length;
        sizePointerBuffer[0] = envByteLength;
        return 0;
    }
    proc_exit(code) {
        // Throw a sentinel so the wasm stack unwinds back to runtime.js
        // WITHOUT executing the `unreachable` instruction wasi-libc emits
        // after __wasi_proc_exit (which is declared noreturn). Trapping
        // there would mark the wasm call as crashed and may interrupt any
        // browser-side render loop that called _Exit on purpose (e.g.
        // Crafter::Window::StartSync on DOM, which hands the loop to rAF
        // and then exits main without running static destructors).
        console.log(`[wasi] proc_exit(${code})`);
        // Trigger a final flush so anything written this session has the
        // best chance of reaching OPFS before the page is torn down.
        opfsFlushAll();
        const e = new Error(`wasi proc_exit(${code})`);
        e.crafterWasiExit = code;
        throw e;
    }
}

const wasmUrl = window.CRAFTER_WASM_URL;
if (!wasmUrl) {
    throw new Error("runtime.js: window.CRAFTER_WASM_URL is not set (set it in index.html before loading runtime.js)");
}

// Preload asset files listed in files.json (emitted by
// EnableWasiBrowserRuntime) into the read-only baked layer so wasi-libc's
// file syscalls work against them. Browser builds otherwise can't open
// assets shipped alongside the .wasm — sync XHR is too deprecated to rely
// on.
//
// Manifest entries are relative paths under the bin dir (the layout
// `cfg.assets` produces — e.g. "assets/Inter.ttf",
// "mods/3DForts_Base/foo.cmesh"). We fetch each at its full path but key
// the read-only map by basename so `path_open`'s basename-reduction can
// find it regardless of the C++ side's cwd or prefix.
try {
    const manifestResp = await fetch("files.json");
    if (manifestResp.ok) {
        const names = await manifestResp.json();
        await Promise.all(names.map(async (name) => {
            const r = await fetch(name);
            if (!r.ok) {
                console.warn(`[wasi] failed to preload ${name}: HTTP ${r.status}`);
                return;
            }
            const base = name.split(/[\\/]/).filter(Boolean).pop() || name;
            readonlyVfs.set(base, new Uint8Array(await r.arrayBuffer()));
        }));
    }
} catch (e) {
    console.warn("[wasi] no files.json manifest (or fetch failed); file I/O syscalls will return ENOENT:", e.message);
}

// Hydrate the persistent layer from OPFS. Must complete before main()
// runs so any std::ifstream on /persistent/* sees the on-disk bytes.
await opfsHydrate();

// Best-effort final flush as the page is torn down. `pagehide` is the
// modern equivalent of `unload`; it fires on tab close + bfcache eviction
// + cross-document navigation. The browser MAY kill the page before the
// async writes complete — the periodic FLUSH_DEBOUNCE_MS timer is the
// real durability guarantee for writes that happen close to shutdown.
window.addEventListener("pagehide", () => { opfsFlushAll(); });

const wasi = new Wasi({ stdin: "", env: {}, args: [] });

// Modules that need env imports (Crafter.Graphics DOM mode, etc.) ship a
// co-located env.js that sets `window.crafter_webbuild_env`. The
// `EnableWasiBrowserRuntime` injects each one as a regular <script> tag
// before this module script, so by the time we instantiate they've all
// populated the global. Pure-WASI builds leave the global undefined and
// we pass an empty object — extra imports on the JS side are harmless
// (WebAssembly only complains about *missing* declared imports).
if (!window.crafter_webbuild_env) {
    window.crafter_webbuild_env = {};
}
// Some env.js bridges (notably the Crafter.CppDOM one) expect an indirect
// function table they can push function references onto. Set it up so we
// don't break compatibility with that pattern.
window.crafter_webbuild_env.table = new WebAssembly.Table({ initial: 4, element: "anyfunc" });

// Async env bridges (notably the WebGPU one in Crafter.Graphics) set
// `window.crafter_webbuild_env_ready` to a Promise that resolves once
// their init (adapter/device requests, pipeline compilation, etc.) is
// finished AND env.* has been swapped from sync stubs to real impls.
// We MUST await this BEFORE WebAssembly.instantiateStreaming — the wasm
// snapshots its import functions at instantiate time, so stubs captured
// then are baked in. Sibling <script type="module"> top-level awaits
// aren't reliably serialized cross-browser, so we can't rely on dom-*
// scripts' own TLAs to block us here.
if (window.crafter_webbuild_env_ready) {
    try {
        await window.crafter_webbuild_env_ready;
    } catch (e) {
        console.error("[crafter] env bridge init failed:", e);
        // Continue to instantiation anyway — the bridge's stubs throw a
        // clearer error from their own call sites.
    }
}

const { instance } = await WebAssembly.instantiateStreaming(fetch(wasmUrl), {
    wasi_snapshot_preview1: wasi,
    env: window.crafter_webbuild_env,
});
wasi.instance = instance;
// Alias under both names — `crafter_wasi` is the canonical, but the older
// CppDOM env.js reads from `crafter_webbuild_wasi`. Keep both wired so
// either generation of env.js works against this runtime.
window.crafter_wasi = wasi;
window.crafter_webbuild_wasi = wasi;

try {
    instance.exports._start();
} catch (e) {
    if (e && typeof e.crafterWasiExit === "number") {
        // Clean exit from std::_Exit / __wasi_proc_exit. The wasm instance
        // remains valid; any rAF callback registered before exit keeps
        // running. (See Crafter::Window::StartSync DOM impl.)
    } else {
        throw e;
    }
}