@aptre/v86 0.5.0 → 0.6.1

package/dist/v86.js

@@ -106,6 +106,7 @@ var FW_CFG_FILE_START = 49152;
 var FW_CFG_SIGNATURE_QEMU = 1431127377;
 var WASM_TABLE_SIZE = 900;
 var WASM_TABLE_OFFSET = 1024;
+var WASM_PAGE_SIZE = 65536;
 var MIXER_CHANNEL_LEFT = 0;
 var MIXER_CHANNEL_RIGHT = 1;
 var MIXER_CHANNEL_BOTH = 2;
@@ -5420,17 +5421,18 @@ var VirtIO = class {
                 LOG_VIRTIO
               );
             }
-            if (data & ~this.device_status & VIRTIO_STATUS_DRIVER_OK && this.device_status & VIRTIO_STATUS_DEVICE_NEEDS_RESET) {
-              this.notify_config_changes();
-            }
             if (!this.features_ok) {
               if (false) {
                 dbg_log("Removing FEATURES_OK", LOG_VIRTIO);
               }
               data &= ~VIRTIO_STATUS_FEATURES_OK;
             }
+            const prev_status = this.device_status;
             this.device_status = data;
-            if (data & ~this.device_status & VIRTIO_STATUS_DRIVER_OK) {
+            if (data & ~prev_status & VIRTIO_STATUS_DRIVER_OK) {
+              if (prev_status & VIRTIO_STATUS_DEVICE_NEEDS_RESET) {
+                this.notify_config_changes();
+              }
               options.on_driver_ok();
             }
           }
@@ -5667,7 +5669,7 @@ var VirtIO = class {
   // Call only within constructor.
   init_capabilities(capabilities) {
     let cap_next = this.pci_space[52] = 64;
-    let cap_ptr = cap_next;
+    let cap_ptr;
     for (const cap of capabilities) {
       const cap_len2 = VIRTIO_PCI_CAP_LENGTH + cap.extra.length;
       cap_ptr = cap_next;
@@ -6888,7 +6890,7 @@ var PCI = class {
       (out_byte) => {
         if ((this.pci_addr[1] & 6) === 2 && (out_byte & 6) === 6) {
           dbg_log("CPU reboot via PCI");
-          cpu.reboot_internal();
+          cpu.reboot();
           return;
         }
         this.pci_addr[1] = out_byte;
@@ -6994,6 +6996,7 @@ var PCI = class {
         0,
         0,
         0,
+        0,
         PAM0,
         0,
         0,
@@ -7306,7 +7309,11 @@ var PCI = class {
     dbg_assert(device.pci_space.length >= 64);
     dbg_assert(device_id < this.devices.length);
     const space = new Int32Array(64);
-    space.set(new Int32Array(new Uint8Array(device.pci_space).buffer));
+    const pci_bytes = new Uint8Array(device.pci_space);
+    const aligned_len = pci_bytes.length & ~3;
+    if (aligned_len > 0) {
+      space.set(new Int32Array(pci_bytes.buffer, 0, aligned_len >> 2));
+    }
     this.device_spaces[device_id] = space;
     this.devices[device_id] = device;
     const bar_space = space.slice(4, 10);
@@ -7957,7 +7964,7 @@ var PS2 = class {
         break;
       case 254:
         dbg_log("CPU reboot via PS2");
-        this.cpu.reboot_internal();
+        this.cpu.reboot();
         break;
       default:
         dbg_log(
@@ -15102,12 +15109,930 @@ var VirtioBalloon = class {
   }
 };
 
+// src/virtio_mem.ts
+var VIRTIO_MEM_REQ_PLUG = 0;
+var VIRTIO_MEM_REQ_UNPLUG = 1;
+var VIRTIO_MEM_REQ_STATE = 3;
+var VIRTIO_MEM_RESP_ACK = 0;
+var VIRTIO_MEM_RESP_NACK = 1;
+var VIRTIO_MEM_RESP_ERROR = 3;
+var DEFAULT_BLOCK_SIZE = 128 * 1024 * 1024;
+var VirtioMem = class {
+  bus;
+  cpu;
+  virtio;
+  block_size;
+  region_addr;
+  region_size;
+  usable_region_size;
+  plugged_size;
+  requested_size;
+  constructor(cpu, bus, region_addr, region_size, block_size) {
+    this.bus = bus;
+    this.cpu = cpu;
+    this.block_size = block_size || DEFAULT_BLOCK_SIZE;
+    this.region_addr = region_addr;
+    this.region_size = region_size;
+    this.usable_region_size = region_size;
+    this.plugged_size = 0;
+    this.requested_size = 0;
+    const queues = [{ size_supported: 32, notify_offset: 0 }];
+    this.virtio = new VirtIO(cpu, {
+      name: "virtio-mem",
+      pci_id: 13 << 3,
+      device_id: 4184,
+      subsystem_device_id: 24,
+      common: {
+        initial_port: 59392,
+        queues,
+        features: [VIRTIO_F_VERSION_1],
+        on_driver_ok: () => {
+          dbg_log("virtio-mem setup", LOG_PCI);
+        }
+      },
+      notification: {
+        initial_port: 59648,
+        single_handler: false,
+        handlers: [
+          (queue_id) => {
+            this.handle_request(queue_id);
+          }
+        ]
+      },
+      isr_status: {
+        initial_port: 59136
+      },
+      device_specific: {
+        initial_port: 58880,
+        struct: [
+          // block_size low
+          {
+            bytes: 4,
+            name: "block_size_low",
+            read: () => this.block_size >>> 0,
+            write: () => {
+            }
+          },
+          // block_size high
+          {
+            bytes: 4,
+            name: "block_size_high",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          // node_id (u16 padded to u32)
+          {
+            bytes: 2,
+            name: "node_id",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          // padding (6 bytes as 2+4)
+          {
+            bytes: 2,
+            name: "padding0",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          {
+            bytes: 4,
+            name: "padding1",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          // addr low
+          {
+            bytes: 4,
+            name: "addr_low",
+            read: () => this.region_addr >>> 0,
+            write: () => {
+            }
+          },
+          // addr high
+          {
+            bytes: 4,
+            name: "addr_high",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          // region_size low
+          {
+            bytes: 4,
+            name: "region_size_low",
+            read: () => this.region_size >>> 0,
+            write: () => {
+            }
+          },
+          // region_size high
+          {
+            bytes: 4,
+            name: "region_size_high",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          // usable_region_size low
+          {
+            bytes: 4,
+            name: "usable_region_size_low",
+            read: () => this.usable_region_size >>> 0,
+            write: () => {
+            }
+          },
+          // usable_region_size high
+          {
+            bytes: 4,
+            name: "usable_region_size_high",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          // plugged_size low
+          {
+            bytes: 4,
+            name: "plugged_size_low",
+            read: () => this.plugged_size >>> 0,
+            write: () => {
+            }
+          },
+          // plugged_size high
+          {
+            bytes: 4,
+            name: "plugged_size_high",
+            read: () => 0,
+            write: () => {
+            }
+          },
+          // requested_size low
+          {
+            bytes: 4,
+            name: "requested_size_low",
+            read: () => this.requested_size >>> 0,
+            write: () => {
+            }
+          },
+          // requested_size high
+          {
+            bytes: 4,
+            name: "requested_size_high",
+            read: () => 0,
+            write: () => {
+            }
+          }
+        ]
+      }
+    });
+  }
+  handle_request(queue_id) {
+    const queue = this.virtio.queues[queue_id];
+    while (queue.has_request()) {
+      const bufchain = queue.pop_request();
+      const request = new Uint8Array(bufchain.length_readable);
+      bufchain.get_next_blob(request);
+      const type = request[0] | request[1] << 8;
+      const resp = new Uint8Array(8);
+      let resp_type = VIRTIO_MEM_RESP_ERROR;
+      switch (type) {
+        case VIRTIO_MEM_REQ_PLUG:
+          resp_type = this.handle_plug(request);
+          break;
+        case VIRTIO_MEM_REQ_UNPLUG:
+          resp_type = VIRTIO_MEM_RESP_NACK;
+          break;
+        case VIRTIO_MEM_REQ_STATE:
+          resp_type = this.handle_state(request, resp);
+          break;
+        default:
+          dbg_log("virtio-mem: unknown request type " + type, LOG_PCI);
+      }
+      resp[0] = resp_type & 255;
+      resp[1] = resp_type >> 8 & 255;
+      bufchain.set_next_blob(resp);
+      queue.push_reply(bufchain);
+    }
+    queue.flush_replies();
+  }
+  handle_plug(request) {
+    const addr = (request[8] | request[9] << 8 | request[10] << 16 | request[11] << 24) >>> 0;
+    const nb_blocks = request[16] | request[17] << 8;
+    const size = nb_blocks * this.block_size;
+    const new_plugged = this.plugged_size + size;
+    if (new_plugged > this.usable_region_size) {
+      return VIRTIO_MEM_RESP_NACK;
+    }
+    const new_memory_size = this.cpu.memory_size[0] + size;
+    this.cpu.resize_memory(new_memory_size);
+    this.cpu.full_clear_tlb();
+    this.plugged_size = new_plugged;
+    dbg_log(
+      "virtio-mem: plugged " + nb_blocks + " blocks at 0x" + addr.toString(16) + " (" + (size >> 20) + "MB)",
+      LOG_PCI
+    );
+    return VIRTIO_MEM_RESP_ACK;
+  }
+  handle_state(request, resp) {
+    const addr = (request[8] | request[9] << 8 | request[10] << 16 | request[11] << 24) >>> 0;
+    const nb_blocks = request[16] | request[17] << 8;
+    const offset = addr - this.region_addr;
+    const end = offset + nb_blocks * this.block_size;
+    const all_plugged = end <= this.plugged_size ? 1 : 0;
+    resp[8] = all_plugged & 255;
+    resp[9] = all_plugged >> 8 & 255;
+    return VIRTIO_MEM_RESP_ACK;
+  }
+  set_requested_size(size) {
+    this.requested_size = size;
+    if (this.virtio.device_status & 4) {
+      this.virtio.notify_config_changes();
+    }
+  }
+  get_state() {
+    const state = [];
+    state[0] = this.virtio;
+    state[1] = this.block_size;
+    state[2] = this.region_addr;
+    state[3] = this.region_size;
+    state[4] = this.usable_region_size;
+    state[5] = this.plugged_size;
+    state[6] = this.requested_size;
+    return state;
+  }
+  set_state(state) {
+    this.virtio.set_state(state[0]);
+    this.block_size = state[1];
+    this.region_addr = state[2];
+    this.region_size = state[3];
+    this.usable_region_size = state[4];
+    this.plugged_size = state[5];
+    this.requested_size = state[6];
+  }
+};
+
+// src/virtio_v86fs.ts
+var V86FS_MSG_MOUNT = 0;
+var V86FS_MSG_LOOKUP = 1;
+var V86FS_MSG_GETATTR = 2;
+var V86FS_MSG_READDIR = 3;
+var V86FS_MSG_OPEN = 4;
+var V86FS_MSG_CLOSE = 5;
+var V86FS_MSG_READ = 6;
+var V86FS_MSG_CREATE = 7;
+var V86FS_MSG_WRITE = 8;
+var V86FS_MSG_MKDIR = 9;
+var V86FS_MSG_SETATTR = 10;
+var V86FS_MSG_FSYNC = 11;
+var V86FS_MSG_UNLINK = 12;
+var V86FS_MSG_RENAME = 13;
+var V86FS_MSG_SYMLINK = 14;
+var V86FS_MSG_READLINK = 15;
+var V86FS_MSG_STATFS = 16;
+var V86FS_MSG_INVALIDATE = 32;
+var V86FS_MSG_INVALIDATE_DIR = 33;
+var V86FS_MSG_MOUNT_R = 128;
+var V86FS_MSG_LOOKUP_R = 129;
+var V86FS_MSG_GETATTR_R = 130;
+var V86FS_MSG_READDIR_R = 131;
+var V86FS_MSG_OPEN_R = 132;
+var V86FS_MSG_CLOSE_R = 133;
+var V86FS_MSG_READ_R = 134;
+var V86FS_MSG_CREATE_R = 135;
+var V86FS_MSG_WRITE_R = 136;
+var V86FS_MSG_MKDIR_R = 137;
+var V86FS_MSG_SETATTR_R = 138;
+var V86FS_MSG_FSYNC_R = 139;
+var V86FS_MSG_UNLINK_R = 140;
+var V86FS_MSG_RENAME_R = 141;
+var V86FS_MSG_SYMLINK_R = 142;
+var V86FS_MSG_READLINK_R = 143;
+var V86FS_MSG_STATFS_R = 144;
+var ATTR_MODE = 1;
+var ATTR_SIZE = 8;
+var V86FS_STATUS_OK = 0;
+var V86FS_STATUS_ENOENT = 2;
+var DT_DIR = 4;
+var DT_REG = 8;
+var DT_LNK = 10;
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+var S_IFLNK = 40960;
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+var FS_ENTRIES = /* @__PURE__ */ new Map([
+  [
+    1,
+    [
+      {
+        inode_id: 2,
+        name: "hello.txt",
+        mode: S_IFREG | 420,
+        size: 12,
+        dt_type: DT_REG,
+        mtime_sec: 17115e5,
+        mtime_nsec: 0,
+        content: textEncoder.encode("hello world\n")
+      },
+      {
+        inode_id: 3,
+        name: "subdir",
+        mode: S_IFDIR | 493,
+        size: 0,
+        dt_type: DT_DIR,
+        mtime_sec: 17115e5,
+        mtime_nsec: 0
+      }
+    ]
+  ]
+]);
+var INODE_MAP = /* @__PURE__ */ new Map([
+  [
+    1,
+    {
+      inode_id: 1,
+      name: "",
+      mode: S_IFDIR | 493,
+      size: 0,
+      dt_type: DT_DIR,
+      mtime_sec: 17115e5,
+      mtime_nsec: 0
+    }
+  ]
+]);
+for (const entries of FS_ENTRIES.values()) {
+  for (const e of entries) {
+    INODE_MAP.set(e.inode_id, e);
+  }
+}
+var V86FS_HDR_SIZE = 7;
+function packU32(buf, offset, val) {
+  buf[offset] = val & 255;
+  buf[offset + 1] = val >>> 8 & 255;
+  buf[offset + 2] = val >>> 16 & 255;
+  buf[offset + 3] = val >>> 24 & 255;
+}
+function packU64(buf, offset, val) {
+  packU32(buf, offset, val);
+  packU32(buf, offset + 4, 0);
+}
+function packU16(buf, offset, val) {
+  buf[offset] = val & 255;
+  buf[offset + 1] = val >>> 8 & 255;
+}
+function makeResp(size, type, tag) {
+  const resp = new Uint8Array(size);
+  packU32(resp, 0, size);
+  resp[4] = type;
+  resp[5] = tag & 255;
+  resp[6] = tag >> 8 & 255;
+  return resp;
+}
+function readU32(buf, offset) {
+  return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24 >>> 0;
+}
+function readU16(buf, offset) {
+  return buf[offset] | buf[offset + 1] << 8;
+}
+function readU64(buf, offset) {
+  return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | (buf[offset + 3] << 24 >>> 0) + (buf[offset + 4] | buf[offset + 5] << 8 | buf[offset + 6] << 16 | buf[offset + 7] << 24 >>> 0) * 4294967296;
+}
+var VirtioV86FS = class {
+  bus;
+  virtio;
+  next_handle_id;
+  next_inode_id;
+  open_handles;
+  // handle_id -> inode_id
+  read_count;
+  constructor(cpu, bus) {
+    this.bus = bus;
+    this.next_handle_id = 1;
+    this.next_inode_id = 100;
+    this.open_handles = /* @__PURE__ */ new Map();
+    this.read_count = 0;
+    const queues = [
+      // Queue 0: hipriq - high-priority metadata (LOOKUP, GETATTR)
+      { size_supported: 128, notify_offset: 0 },
+      // Queue 1: requestq - data requests (READ, WRITE, READDIR)
+      { size_supported: 128, notify_offset: 1 },
+      // Queue 2: notifyq - host-to-guest push invalidation
+      { size_supported: 128, notify_offset: 2 }
+    ];
+    this.virtio = new VirtIO(cpu, {
+      name: "virtio-v86fs",
+      pci_id: 14 << 3,
+      device_id: 4223,
+      subsystem_device_id: 63,
+      common: {
+        initial_port: 63488,
+        queues,
+        features: [VIRTIO_F_VERSION_1],
+        on_driver_ok: () => {
+          console.log("v86fs: driver ok");
+          this.bus.send("virtio-v86fs-driver-ok");
+        }
+      },
+      notification: {
+        initial_port: 63744,
+        single_handler: false,
+        handlers: [
+          // Queue 0: hipriq
+          (queue_id) => {
+            this.handle_queue(queue_id);
+          },
+          // Queue 1: requestq
+          (queue_id) => {
+            this.handle_queue(queue_id);
+          },
+          // Queue 2: notifyq
+          (_queue_id) => {
+            dbg_log("v86fs: notifyq notification", LOG_PCI);
+          }
+        ]
+      },
+      isr_status: {
+        initial_port: 63232
+      }
+    });
+  }
+  handle_queue(queue_id) {
+    const queue = this.virtio.queues[queue_id];
+    while (queue.has_request()) {
+      const bufchain = queue.pop_request();
+      const req = new Uint8Array(bufchain.length_readable);
+      bufchain.get_next_blob(req);
+      const resp = this.handle_message(req);
+      if (resp && bufchain.length_writable > 0) {
+        bufchain.set_next_blob(resp);
+      }
+      queue.push_reply(bufchain);
+    }
+    queue.flush_replies();
+  }
+  handle_message(req) {
+    if (req.length < V86FS_HDR_SIZE) {
+      console.warn("v86fs: message too short:", req.length);
+      return null;
+    }
+    const type = req[4];
+    const tag = readU16(req, 5);
+    switch (type) {
+      case V86FS_MSG_MOUNT:
+        return this.handle_mount(req, tag);
+      case V86FS_MSG_LOOKUP:
+        return this.handle_lookup(req, tag);
+      case V86FS_MSG_GETATTR:
+        return this.handle_getattr(req, tag);
+      case V86FS_MSG_READDIR:
+        return this.handle_readdir(req, tag);
+      case V86FS_MSG_OPEN:
+        return this.handle_open(req, tag);
+      case V86FS_MSG_CLOSE:
+        return this.handle_close(req, tag);
+      case V86FS_MSG_READ:
+        return this.handle_read(req, tag);
+      case V86FS_MSG_CREATE:
+        return this.handle_create(req, tag);
+      case V86FS_MSG_WRITE:
+        return this.handle_write(req, tag);
+      case V86FS_MSG_MKDIR:
+        return this.handle_mkdir(req, tag);
+      case V86FS_MSG_SETATTR:
+        return this.handle_setattr(req, tag);
+      case V86FS_MSG_FSYNC:
+        return this.handle_fsync(req, tag);
+      case V86FS_MSG_UNLINK:
+        return this.handle_unlink(req, tag);
+      case V86FS_MSG_RENAME:
+        return this.handle_rename(req, tag);
+      case V86FS_MSG_SYMLINK:
+        return this.handle_symlink(req, tag);
+      case V86FS_MSG_READLINK:
+        return this.handle_readlink(req, tag);
+      case V86FS_MSG_STATFS:
+        return this.handle_statfs(tag);
+      default:
+        console.warn("v86fs: unknown message type:", type);
+        return null;
+    }
+  }
+  handle_mount(req, tag) {
+    const name_len = readU16(req, 7);
+    const name = name_len > 0 ? textDecoder.decode(req.subarray(9, 9 + name_len)) : "";
+    console.log("v86fs: mount:", name || "(default)");
+    this.bus.send("virtio-v86fs-mount", name);
+    const resp = new Uint8Array(23);
+    packU32(resp, 0, 23);
+    resp[4] = V86FS_MSG_MOUNT_R;
+    resp[5] = tag & 255;
+    resp[6] = tag >> 8 & 255;
+    packU32(resp, 7, 0);
+    packU64(resp, 11, 1);
+    packU32(resp, 19, 16877);
+    return resp;
+  }
+  handle_getattr(req, tag) {
+    const inode_id = readU64(req, 7);
+    const entry = INODE_MAP.get(inode_id);
+    const resp = makeResp(35, V86FS_MSG_GETATTR_R, tag);
+    if (!entry) {
+      packU32(resp, 7, V86FS_STATUS_ENOENT);
+      return resp;
+    }
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU32(resp, 11, entry.mode);
+    packU64(resp, 15, entry.size);
+    packU64(resp, 23, entry.mtime_sec);
+    packU32(resp, 31, entry.mtime_nsec);
+    return resp;
+  }
+  handle_lookup(req, tag) {
+    const parent_id = readU64(req, 7);
+    const name_len = readU16(req, 15);
+    const name = textDecoder.decode(req.subarray(17, 17 + name_len));
+    const entries = FS_ENTRIES.get(parent_id);
+    const entry = entries?.find((e) => e.name === name);
+    const resp = new Uint8Array(31);
+    packU32(resp, 0, 31);
+    resp[4] = V86FS_MSG_LOOKUP_R;
+    resp[5] = tag & 255;
+    resp[6] = tag >> 8 & 255;
+    if (!entry) {
+      packU32(resp, 7, V86FS_STATUS_ENOENT);
+      return resp;
+    }
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU64(resp, 11, entry.inode_id);
+    packU32(resp, 19, entry.mode);
+    packU64(resp, 23, entry.size);
+    return resp;
+  }
+  handle_readdir(req, tag) {
+    const dir_id = readU64(req, 7);
+    const entries = FS_ENTRIES.get(dir_id) || [];
+    const encodedNames = entries.map((e) => textEncoder.encode(e.name));
+    let size = 7 + 4 + 4;
+    for (const nameBytes of encodedNames) {
+      size += 8 + 1 + 2 + nameBytes.length;
+    }
+    const resp = makeResp(size, V86FS_MSG_READDIR_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU32(resp, 11, entries.length);
+    let off = 15;
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      const nameBytes = encodedNames[i];
+      packU64(resp, off, e.inode_id);
+      resp[off + 8] = e.dt_type;
+      packU16(resp, off + 9, nameBytes.length);
+      resp.set(nameBytes, off + 11);
+      off += 11 + nameBytes.length;
+    }
+    return resp;
+  }
+  handle_open(req, tag) {
+    const inode_id = readU64(req, 7);
+    const handle_id = this.next_handle_id++;
+    this.open_handles.set(handle_id, inode_id);
+    this.bus.send("virtio-v86fs-open", inode_id);
+    const resp = makeResp(19, V86FS_MSG_OPEN_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU64(resp, 11, handle_id);
+    return resp;
+  }
+  handle_close(req, tag) {
+    const handle_id = readU64(req, 7);
+    this.open_handles.delete(handle_id);
+    this.bus.send("virtio-v86fs-close", handle_id);
+    const resp = makeResp(11, V86FS_MSG_CLOSE_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    return resp;
+  }
+  handle_read(req, tag) {
+    const handle_id = readU64(req, 7);
+    const offset = readU64(req, 15);
+    const size = readU32(req, 23);
+    const inode_id = this.open_handles.get(handle_id) ?? handle_id;
+    const entry = INODE_MAP.get(inode_id);
+    const content = entry?.content;
+    this.read_count++;
+    this.bus.send("virtio-v86fs-read", {
+      handle_id,
+      inode_id,
+      offset,
+      size
+    });
+    if (!content || offset >= content.length) {
+      const resp2 = makeResp(15, V86FS_MSG_READ_R, tag);
+      packU32(resp2, 7, V86FS_STATUS_OK);
+      packU32(resp2, 11, 0);
+      return resp2;
+    }
+    const start = Math.min(offset, content.length);
+    const end = Math.min(start + size, content.length);
+    const data = content.subarray(start, end);
+    const resp = new Uint8Array(15 + data.length);
+    packU32(resp, 0, 15 + data.length);
+    resp[4] = V86FS_MSG_READ_R;
+    resp[5] = tag & 255;
+    resp[6] = tag >> 8 & 255;
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU32(resp, 11, data.length);
+    resp.set(data, 15);
+    return resp;
+  }
+  handle_create(req, tag) {
+    const parent_id = readU64(req, 7);
+    const name_len = readU16(req, 15);
+    const name = textDecoder.decode(req.subarray(17, 17 + name_len));
+    const mode = readU32(req, 17 + name_len);
+    const inode_id = this.next_inode_id++;
+    const entry = {
+      inode_id,
+      name,
+      mode: mode | S_IFREG,
+      size: 0,
+      dt_type: DT_REG,
+      mtime_sec: Math.floor(Date.now() / 1e3),
+      mtime_nsec: 0,
+      content: new Uint8Array(0)
+    };
+    let children = FS_ENTRIES.get(parent_id);
+    if (!children) {
+      children = [];
+      FS_ENTRIES.set(parent_id, children);
+    }
+    children.push(entry);
+    INODE_MAP.set(inode_id, entry);
+    const resp = makeResp(23, V86FS_MSG_CREATE_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU64(resp, 11, inode_id);
+    packU32(resp, 19, entry.mode);
+    return resp;
+  }
+  handle_write(req, tag) {
+    const inode_id = readU64(req, 7);
+    const offset = readU64(req, 15);
+    const size = readU32(req, 23);
+    const data = req.subarray(27, 27 + size);
+    const entry = INODE_MAP.get(inode_id);
+    if (entry) {
+      const needed = offset + size;
+      if (!entry.content || entry.content.length < needed) {
+        const newContent = new Uint8Array(needed);
+        if (entry.content) {
+          newContent.set(entry.content);
+        }
+        entry.content = newContent;
+      }
+      entry.content.set(data, offset);
+      if (needed > entry.size) {
+        entry.size = needed;
+      }
+    }
+    const resp = makeResp(15, V86FS_MSG_WRITE_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU32(resp, 11, size);
+    return resp;
+  }
+  handle_mkdir(req, tag) {
+    const parent_id = readU64(req, 7);
+    const name_len = readU16(req, 15);
+    const name = textDecoder.decode(req.subarray(17, 17 + name_len));
+    const mode = readU32(req, 17 + name_len);
+    const inode_id = this.next_inode_id++;
+    const entry = {
+      inode_id,
+      name,
+      mode: mode | S_IFDIR,
+      size: 0,
+      dt_type: DT_DIR,
+      mtime_sec: Math.floor(Date.now() / 1e3),
+      mtime_nsec: 0
+    };
+    let children = FS_ENTRIES.get(parent_id);
+    if (!children) {
+      children = [];
+      FS_ENTRIES.set(parent_id, children);
+    }
+    children.push(entry);
+    INODE_MAP.set(inode_id, entry);
+    FS_ENTRIES.set(inode_id, []);
+    const resp = makeResp(23, V86FS_MSG_MKDIR_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU64(resp, 11, inode_id);
+    packU32(resp, 19, entry.mode);
+    return resp;
+  }
+  handle_setattr(req, tag) {
+    const inode_id = readU64(req, 7);
+    const valid = readU32(req, 15);
+    const mode = readU32(req, 19);
+    const size = readU64(req, 23);
+    const entry = INODE_MAP.get(inode_id);
+    if (entry) {
+      if (valid & ATTR_MODE) {
+        entry.mode = entry.mode & 61440 | mode & 4095;
+      }
+      if (valid & ATTR_SIZE) {
+        entry.size = size;
+        if (entry.content) {
+          if (size === 0) {
+            entry.content = new Uint8Array(0);
+          } else if (size < entry.content.length) {
+            entry.content = entry.content.subarray(0, size);
+          }
+        }
+      }
+    }
+    const resp = makeResp(11, V86FS_MSG_SETATTR_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    return resp;
+  }
+  handle_fsync(req, tag) {
+    const resp = makeResp(11, V86FS_MSG_FSYNC_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    return resp;
+  }
+  handle_unlink(req, tag) {
+    const parent_id = readU64(req, 7);
+    const name_len = readU16(req, 15);
+    const name = textDecoder.decode(req.subarray(17, 17 + name_len));
+    const children = FS_ENTRIES.get(parent_id);
+    let status = V86FS_STATUS_ENOENT;
+    if (children) {
+      const idx = children.findIndex((e) => e.name === name);
+      if (idx >= 0) {
+        const entry = children[idx];
+        INODE_MAP.delete(entry.inode_id);
+        FS_ENTRIES.delete(entry.inode_id);
+        children.splice(idx, 1);
+        status = V86FS_STATUS_OK;
+      }
+    }
+    const resp = makeResp(11, V86FS_MSG_UNLINK_R, tag);
+    packU32(resp, 7, status);
+    return resp;
+  }
+  handle_rename(req, tag) {
+    let off = 7;
+    const old_parent_id = readU64(req, off);
+    off += 8;
+    const old_name_len = readU16(req, off);
+    off += 2;
+    const old_name = textDecoder.decode(
+      req.subarray(off, off + old_name_len)
+    );
+    off += old_name_len;
+    const new_parent_id = readU64(req, off);
+    off += 8;
+    const new_name_len = readU16(req, off);
+    off += 2;
+    const new_name = textDecoder.decode(
+      req.subarray(off, off + new_name_len)
+    );
+    let status = V86FS_STATUS_ENOENT;
+    const old_children = FS_ENTRIES.get(old_parent_id);
+    if (old_children) {
+      const idx = old_children.findIndex((e) => e.name === old_name);
+      if (idx >= 0) {
+        const entry = old_children[idx];
+        old_children.splice(idx, 1);
+        entry.name = new_name;
+        let new_children = FS_ENTRIES.get(new_parent_id);
+        if (!new_children) {
+          new_children = [];
+          FS_ENTRIES.set(new_parent_id, new_children);
+        }
+        const existing = new_children.findIndex(
+          (e) => e.name === new_name
+        );
+        if (existing >= 0) {
+          const old_entry = new_children[existing];
+          INODE_MAP.delete(old_entry.inode_id);
+          new_children.splice(existing, 1);
+        }
+        new_children.push(entry);
+        status = V86FS_STATUS_OK;
+      }
+    }
+    const resp = makeResp(11, V86FS_MSG_RENAME_R, tag);
+    packU32(resp, 7, status);
+    return resp;
+  }
+  handle_symlink(req, tag) {
+    let off = 7;
+    const parent_id = readU64(req, off);
+    off += 8;
+    const name_len = readU16(req, off);
+    off += 2;
+    const name = textDecoder.decode(req.subarray(off, off + name_len));
+    off += name_len;
+    const target_len = readU16(req, off);
+    off += 2;
+    const target = textDecoder.decode(req.subarray(off, off + target_len));
+    const inode_id = this.next_inode_id++;
+    const entry = {
+      inode_id,
+      name,
+      mode: S_IFLNK | 511,
+      size: target.length,
+      dt_type: DT_LNK,
+      mtime_sec: Math.floor(Date.now() / 1e3),
+      mtime_nsec: 0,
+      symlink_target: target
+    };
+    let children = FS_ENTRIES.get(parent_id);
+    if (!children) {
+      children = [];
+      FS_ENTRIES.set(parent_id, children);
+    }
+    children.push(entry);
+    INODE_MAP.set(inode_id, entry);
+    const resp = makeResp(23, V86FS_MSG_SYMLINK_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU64(resp, 11, inode_id);
+    packU32(resp, 19, entry.mode);
+    return resp;
+  }
+  handle_readlink(req, tag) {
+    const inode_id = readU64(req, 7);
+    const entry = INODE_MAP.get(inode_id);
+    if (!entry || !entry.symlink_target) {
+      const resp2 = makeResp(11, V86FS_MSG_READLINK_R, tag);
+      packU32(resp2, 7, V86FS_STATUS_ENOENT);
+      return resp2;
+    }
+    const target_bytes = textEncoder.encode(entry.symlink_target);
+    const resp_len = 11 + 2 + target_bytes.length;
+    const resp = makeResp(resp_len, V86FS_MSG_READLINK_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU16(resp, 11, target_bytes.length);
+    resp.set(target_bytes, 13);
+    return resp;
+  }
+  handle_statfs(tag) {
+    const resp = makeResp(55, V86FS_MSG_STATFS_R, tag);
+    packU32(resp, 7, V86FS_STATUS_OK);
+    packU64(resp, 11, 1024 * 1024);
+    packU64(resp, 19, 512 * 1024);
+    packU64(resp, 27, 512 * 1024);
+    packU64(resp, 35, 1024 * 1024);
+    packU64(resp, 43, 512 * 1024);
+    packU32(resp, 51, 4096);
+    return resp;
+  }
+  /** Push an INVALIDATE notification to the guest via notifyq.
+   *  Guest kernel will invalidate page cache for the given inode. */
+  invalidate_inode(inode_id) {
+    const queue = this.virtio.queues[2];
+    if (!queue.has_request()) return false;
+    const bufchain = queue.pop_request();
+    const msg = new Uint8Array(15);
+    packU32(msg, 0, 15);
+    msg[4] = V86FS_MSG_INVALIDATE;
+    packU16(msg, 5, 0);
+    packU64(msg, 7, inode_id);
+    bufchain.set_next_blob(msg);
+    queue.push_reply(bufchain);
+    queue.flush_replies();
+    return true;
+  }
+  /** Push an INVALIDATE_DIR notification to the guest via notifyq.
+   *  Guest kernel will invalidate dcache for the given directory inode. */
+  invalidate_dir(inode_id) {
+    const queue = this.virtio.queues[2];
+    if (!queue.has_request()) return false;
+    const bufchain = queue.pop_request();
+    const msg = new Uint8Array(15);
+    packU32(msg, 0, 15);
+    msg[4] = V86FS_MSG_INVALIDATE_DIR;
+    packU16(msg, 5, 0);
+    packU64(msg, 7, inode_id);
+    bufchain.set_next_blob(msg);
+    queue.push_reply(bufchain);
+    queue.flush_replies();
+    return true;
+  }
+  get_state() {
+    const state = [];
+    state[0] = this.virtio;
+    return state;
+  }
+  set_state(state) {
+    this.virtio.set_state(state[0]);
+  }
+};
+
 // lib/filesystem.ts
 var S_IFMT = 61440;
 var S_IFSOCK = 49152;
-var S_IFLNK = 40960;
-var S_IFREG = 32768;
-var S_IFDIR = 16384;
+var S_IFLNK2 = 40960;
+var S_IFREG2 = 32768;
+var S_IFDIR2 = 16384;
 var STATUS_INVALID = -1;
 var STATUS_OK = 0;
 var STATUS_ON_STORAGE = 2;
@@ -15200,11 +16125,11 @@ var Inode = class {
   get_state() {
     const state = [];
     state[0] = this.mode;
-    if ((this.mode & S_IFMT) === S_IFDIR) {
+    if ((this.mode & S_IFMT) === S_IFDIR2) {
       state[1] = [...this.direntries];
-    } else if ((this.mode & S_IFMT) === S_IFREG) {
+    } else if ((this.mode & S_IFMT) === S_IFREG2) {
       state[1] = this.sha256sum;
-    } else if ((this.mode & S_IFMT) === S_IFLNK) {
+    } else if ((this.mode & S_IFMT) === S_IFLNK2) {
       state[1] = this.symlink;
     } else if ((this.mode & S_IFMT) === S_IFSOCK) {
       state[1] = [this.minor, this.major];
@@ -15227,14 +16152,14 @@ var Inode = class {
   }
   set_state(state) {
     this.mode = state[0];
-    if ((this.mode & S_IFMT) === S_IFDIR) {
+    if ((this.mode & S_IFMT) === S_IFDIR2) {
       this.direntries = /* @__PURE__ */ new Map();
       for (const [name, entry] of state[1]) {
         this.direntries.set(name, entry);
       }
-    } else if ((this.mode & S_IFMT) === S_IFREG) {
+    } else if ((this.mode & S_IFMT) === S_IFREG2) {
       this.sha256sum = state[1];
-    } else if ((this.mode & S_IFMT) === S_IFLNK) {
+    } else if ((this.mode & S_IFMT) === S_IFLNK2) {
       this.symlink = state[1];
     } else if ((this.mode & S_IFMT) === S_IFSOCK) {
       ;
@@ -15303,7 +16228,7 @@ var FS = class {
     state[1] = this.qidcounter.last_qidnumber;
     state[2] = [];
     for (const [id, data] of Object.entries(this.inodedata)) {
-      if ((this.inodes[Number(id)].mode & S_IFDIR) === 0) {
+      if ((this.inodes[Number(id)].mode & S_IFDIR2) === 0) {
         state[2].push([id, data]);
       }
     }
@@ -15354,15 +16279,15 @@ var FS = class {
     inode.uid = data[JSONFS_IDX_UID];
     inode.gid = data[JSONFS_IDX_GID];
     const ifmt = inode.mode & S_IFMT;
-    if (ifmt === S_IFDIR) {
+    if (ifmt === S_IFDIR2) {
       this.PushInode(inode, parentid, name);
       this.LoadDir(this.inodes.length - 1, data[JSONFS_IDX_TARGET]);
-    } else if (ifmt === S_IFREG) {
+    } else if (ifmt === S_IFREG2) {
       inode.status = STATUS_ON_STORAGE;
       inode.sha256sum = data[JSONFS_IDX_SHA256];
       dbg_assert(!!inode.sha256sum);
       this.PushInode(inode, parentid, name);
-    } else if (ifmt === S_IFLNK) {
+    } else if (ifmt === S_IFLNK2) {
       inode.symlink = data[JSONFS_IDX_TARGET];
       this.PushInode(inode, parentid, name);
     } else if (ifmt === S_IFSOCK) {
@@ -15534,13 +16459,13 @@ var FS = class {
       return this.create_forwarder(parent_inode.mount_id, foreign_id);
     }
     const x = this.CreateInode();
-    x.mode = 511 | S_IFDIR;
+    x.mode = 511 | S_IFDIR2;
     if (parentid >= 0) {
       x.uid = this.inodes[parentid].uid;
       x.gid = this.inodes[parentid].gid;
-      x.mode = this.inodes[parentid].mode & 511 | S_IFDIR;
+      x.mode = this.inodes[parentid].mode & 511 | S_IFDIR2;
     }
-    x.qid.type = S_IFDIR >> 8;
+    x.qid.type = S_IFDIR2 >> 8;
     this.PushInode(x, parentid, name);
     this.NotifyListeners(this.inodes.length - 1, "newdir");
     return this.inodes.length - 1;
@@ -15558,8 +16483,8 @@ var FS = class {
     const x = this.CreateInode();
     x.uid = this.inodes[parentid].uid;
     x.gid = this.inodes[parentid].gid;
-    x.qid.type = S_IFREG >> 8;
-    x.mode = this.inodes[parentid].mode & 438 | S_IFREG;
+    x.qid.type = S_IFREG2 >> 8;
+    x.mode = this.inodes[parentid].mode & 438 | S_IFREG2;
     this.PushInode(x, parentid, filename);
     this.NotifyListeners(this.inodes.length - 1, "newfile");
     return this.inodes.length - 1;
@@ -15600,9 +16525,9 @@ var FS = class {
     const x = this.CreateInode();
     x.uid = this.inodes[parentid].uid;
     x.gid = this.inodes[parentid].gid;
-    x.qid.type = S_IFLNK >> 8;
+    x.qid.type = S_IFLNK2 >> 8;
     x.symlink = symlink;
-    x.mode = S_IFLNK;
+    x.mode = S_IFLNK2;
     this.PushInode(x, parentid, filename);
     return this.inodes.length - 1;
   }
@@ -15647,7 +16572,7 @@ var FS = class {
     if (this.is_forwarder(inode)) {
       return await this.follow_fs(inode).OpenInode(inode.foreign_id, mode);
     }
-    if ((inode.mode & S_IFMT) === S_IFDIR) {
+    if ((inode.mode & S_IFMT) === S_IFDIR2) {
       this.FillDirectory(id);
     }
   }
@@ -16002,7 +16927,7 @@ var FS = class {
     let parentid = -1;
     let id = 0;
     let forward_path = null;
-    let i = 0;
+    let i;
     for (i = 0; i < n; i++) {
       parentid = id;
       id = this.Search(parentid, walk[i]);
@@ -16068,13 +16993,13 @@ var FS = class {
   DeleteNode(path) {
     const ids = this.SearchPath(path);
     if (ids.id === -1) return;
-    if ((this.inodes[ids.id].mode & S_IFMT) === S_IFREG) {
+    if ((this.inodes[ids.id].mode & S_IFMT) === S_IFREG2) {
       const ret = this.Unlink(ids.parentid, ids.name);
       dbg_assert(
         ret === 0,
         "Filesystem DeleteNode failed with error code: " + -ret
       );
-    } else if ((this.inodes[ids.id].mode & S_IFMT) === S_IFDIR) {
+    } else if ((this.inodes[ids.id].mode & S_IFMT) === S_IFDIR2) {
       this.RecursiveDelete(path);
       const ret = this.Unlink(ids.parentid, ids.name);
       dbg_assert(
@@ -16178,7 +17103,7 @@ var FS = class {
     if (this.is_forwarder(inode)) {
       return this.follow_fs(inode).IsDirectory(inode.foreign_id);
     }
-    return (inode.mode & S_IFMT) === S_IFDIR;
+    return (inode.mode & S_IFMT) === S_IFDIR2;
   }
   IsEmpty(idx) {
     const inode = this.inodes[idx];
@@ -16708,7 +17633,7 @@ var Virtio9p = class {
     bufchain.get_next_blob(buffer);
     const state = { offset: 0 };
     const header = Unmarshall(["w", "b", "h"], buffer, state);
-    let size = header[0];
+    let size;
     const id = header[1];
     const tag = header[2];
     switch (id) {
@@ -16769,7 +17694,7 @@ var Virtio9p = class {
           name
         );
         if (ret < 0) {
-          let error_message = "";
+          let error_message;
           if (ret === -EPERM)
             error_message = "Operation not permitted";
           else {
@@ -16882,7 +17807,7 @@ var Virtio9p = class {
           this.fids[fid].inodeid
         );
         const inode = this.fs.GetInode(idx);
-        inode.mode = mode | S_IFDIR;
+        inode.mode = mode | S_IFDIR2;
         inode.uid = this.fids[fid].uid;
         inode.gid = gid;
         Marshall(["Q"], [inode.qid], this.replybuffer, 7);
@@ -16913,7 +17838,7 @@ var Virtio9p = class {
         const inode = this.fs.GetInode(idx);
         inode.uid = this.fids[fid].uid;
         inode.gid = gid;
-        inode.mode = mode | S_IFREG;
+        inode.mode = mode | S_IFREG2;
         Marshall(
           ["Q", "w"],
           [inode.qid, this.msize - 24],
@@ -17238,7 +18163,7 @@ var Virtio9p = class {
           newname
         );
         if (ret < 0) {
-          let error_message = "";
+          let error_message;
           if (ret === -ENOENT)
             error_message = "No such file or directory";
           else if (ret === -EPERM)
@@ -17287,7 +18212,7 @@ var Virtio9p = class {
         }
         const ret = this.fs.Unlink(this.fids[dirfd].inodeid, name);
         if (ret < 0) {
-          let error_message = "";
+          let error_message;
           if (ret === -ENOTEMPTY)
             error_message = "Directory not empty";
           else if (ret === -EPERM)
@@ -17861,6 +18786,7 @@ var CPU = class {
   wasm_memory;
   memory_size;
   mem8;
+  mem8_offset = 0;
   mem32s;
   segment_is_null;
   segment_offsets;
@@ -17939,7 +18865,6 @@ var CPU = class {
   get_eflags;
   handle_irqs;
   main_loop;
-  reboot_internal;
   set_jit_config;
   read8;
   read16;
@@ -17988,13 +18913,49 @@ var CPU = class {
     this.name = "cpu";
     this.stop_idling = stop_idling;
     this.wm = wm;
+    this.wasm_memory = wm.wasm_memory;
     this.wasm_patch();
     this.create_jit_imports();
-    const memory = this.wm.exports["memory"];
-    this.wasm_memory = memory;
-    this.memory_size = view(Uint32Array, memory, 812, 1);
     this.mem8 = new Uint8Array(0);
     this.mem32s = new Int32Array(this.mem8.buffer);
+    this.rebuild_wasm_views();
+    this.devices = {};
+    this.memory_map_read8 = [];
+    this.memory_map_write8 = [];
+    this.memory_map_read32 = [];
+    this.memory_map_write32 = [];
+    this.bios = {
+      main: null,
+      vga: null
+    };
+    this.fpu_stack_empty[0] = 255;
+    this.fpu_stack_ptr[0] = 0;
+    this.fpu_control_word[0] = 895;
+    this.fpu_status_word[0] = 0;
+    this.fpu_ip[0] = 0;
+    this.fpu_ip_selector[0] = 0;
+    this.fpu_opcode[0] = 0;
+    this.fpu_dp[0] = 0;
+    this.fpu_dp_selector[0] = 0;
+    this.fw_value = [];
+    this.fw_pointer = 0;
+    this.option_roms = [];
+    this.io = void 0;
+    this.bus = bus;
+    this.set_tsc(0, 0);
+    if (false) {
+      this.seen_code = {};
+      this.seen_code_uncompiled = {};
+    }
+  }
+  /**
+   * Rebuild all TypedArray views into WASM linear memory.
+   * Must be called after any wasm_memory.grow() since growth
+   * detaches the old ArrayBuffer, invalidating all views.
+   */
+  rebuild_wasm_views() {
+    const memory = this.wasm_memory;
+    this.memory_size = view(Uint32Array, memory, 812, 1);
     this.segment_is_null = view(Uint8Array, memory, 724, 8);
     this.segment_offsets = view(Int32Array, memory, 736, 8);
     this.segment_limits = view(Uint32Array, memory, 768, 8);
@@ -18023,40 +18984,22 @@ var CPU = class {
     this.last_op1 = view(Int32Array, memory, 104, 1);
     this.last_result = view(Int32Array, memory, 112, 1);
     this.current_tsc = view(Uint32Array, memory, 960, 2);
-    this.devices = {};
     this.instruction_pointer = view(Int32Array, memory, 556, 1);
     this.previous_ip = view(Int32Array, memory, 560, 1);
     this.apic_enabled = view(Uint8Array, memory, 548, 1);
     this.acpi_enabled = view(Uint8Array, memory, 552, 1);
-    this.memory_map_read8 = [];
-    this.memory_map_write8 = [];
-    this.memory_map_read32 = [];
-    this.memory_map_write32 = [];
-    this.bios = {
-      main: null,
-      vga: null
-    };
     this.instruction_counter = view(Uint32Array, memory, 664, 1);
     this.reg32 = view(Int32Array, memory, 64, 8);
     this.fpu_st = view(Int32Array, memory, 1152, 4 * 8);
     this.fpu_stack_empty = view(Uint8Array, memory, 816, 1);
-    this.fpu_stack_empty[0] = 255;
     this.fpu_stack_ptr = view(Uint8Array, memory, 1032, 1);
-    this.fpu_stack_ptr[0] = 0;
     this.fpu_control_word = view(Uint16Array, memory, 1036, 1);
-    this.fpu_control_word[0] = 895;
     this.fpu_status_word = view(Uint16Array, memory, 1040, 1);
-    this.fpu_status_word[0] = 0;
     this.fpu_ip = view(Int32Array, memory, 1048, 1);
-    this.fpu_ip[0] = 0;
     this.fpu_ip_selector = view(Int32Array, memory, 1052, 1);
-    this.fpu_ip_selector[0] = 0;
     this.fpu_opcode = view(Int32Array, memory, 1044, 1);
-    this.fpu_opcode[0] = 0;
     this.fpu_dp = view(Int32Array, memory, 1056, 1);
-    this.fpu_dp[0] = 0;
     this.fpu_dp_selector = view(Int32Array, memory, 1060, 1);
-    this.fpu_dp_selector[0] = 0;
     this.reg_xmm32s = view(Int32Array, memory, 832, 8 * 4);
     this.mxcsr = view(Int32Array, memory, 824, 1);
     this.sreg = view(Uint16Array, memory, 668, 8);
@@ -18064,16 +19007,6 @@ var CPU = class {
     this.reg_pdpte = view(Int32Array, memory, 968, 8);
     this.svga_dirty_bitmap_min_offset = view(Uint32Array, memory, 716, 1);
     this.svga_dirty_bitmap_max_offset = view(Uint32Array, memory, 720, 1);
-    this.fw_value = [];
-    this.fw_pointer = 0;
-    this.option_roms = [];
-    this.io = void 0;
-    this.bus = bus;
-    this.set_tsc(0, 0);
-    if (false) {
-      this.seen_code = {};
-      this.seen_code_uncompiled = {};
-    }
   }
   mmap_read8(addr) {
     const value = this.memory_map_read8[addr >>> MMAP_BLOCK_BITS](addr);
@@ -18136,7 +19069,7 @@ var CPU = class {
   }
   create_jit_imports() {
     const jit_imports = /* @__PURE__ */ Object.create(null);
-    jit_imports["m"] = this.wm.exports["memory"];
+    jit_imports["m"] = this.wasm_memory;
     for (const name of Object.keys(this.wm.exports)) {
       if (name.startsWith("_") || name.startsWith("zstd") || name.endsWith("_js")) {
         continue;
@@ -18157,7 +19090,6 @@ var CPU = class {
     this.get_eflags = get_import("get_eflags");
     this.handle_irqs = get_import("handle_irqs");
     this.main_loop = get_import("main_loop");
-    this.reboot_internal = get_import("reboot_internal");
     this.set_jit_config = get_import("set_jit_config");
     this.read8 = get_import("read8");
     this.read16 = get_import("read16");
@@ -18314,6 +19246,8 @@ var CPU = class {
     state[86] = this.last_result;
     state[87] = this.fpu_status_word;
     state[88] = this.mxcsr;
+    state[89] = this.devices.virtio_mem;
+    state[90] = this.devices.virtio_v86fs;
     return state;
   }
   get_state_pic() {
@@ -18374,8 +19308,33 @@ var CPU = class {
       IOAPIC_STRUCT_SIZE
     );
   }
+  resize_memory(new_size) {
+    const mem8_offset = this.mem8_offset;
+    const needed_total = mem8_offset + new_size;
+    const current_buffer = this.wasm_memory.buffer.byteLength;
+    if (needed_total > current_buffer) {
+      const grow_pages = Math.ceil(
+        (needed_total - current_buffer) / WASM_PAGE_SIZE
+      );
+      this.wasm_memory.grow(grow_pages);
+      this.rebuild_wasm_views();
+    }
+    this.mem8 = view(Uint8Array, this.wasm_memory, mem8_offset, new_size);
+    this.mem32s = view(
+      Int32Array,
+      this.wasm_memory,
+      mem8_offset,
+      new_size >> 2
+    );
+    this.memory_size[0] = new_size;
+  }
   set_state(state) {
-    this.memory_size[0] = state[0];
+    const saved_memory_size = state[0];
+    if (saved_memory_size > this.memory_size[0]) {
+      this.resize_memory(saved_memory_size);
+    } else {
+      this.memory_size[0] = saved_memory_size;
+    }
     if (this.mem8.length !== this.memory_size[0]) {
       console.warn(
         "Note: Memory size mismatch. we=" + this.mem8.length + " state=" + this.memory_size[0]
@@ -18473,6 +19432,10 @@ var CPU = class {
       this.devices.virtio_net.set_state(state[83]);
     if (this.devices.virtio_balloon)
       this.devices.virtio_balloon.set_state(state[84]);
+    if (this.devices.virtio_mem && state[89])
+      this.devices.virtio_mem.set_state(state[89]);
+    if (this.devices.virtio_v86fs && state[90])
+      this.devices.virtio_v86fs.set_state(state[90]);
     this.fw_value = state[62];
     if (state[63]) this.set_state_ioapic(state[63]);
     this.tss_size_32[0] = state[64];
@@ -18671,8 +19634,10 @@ var CPU = class {
       this.memory_size[0] === 0,
       "Expected uninitialised memory"
     );
-    this.memory_size[0] = size;
     const memory_offset = this.allocate_memory(size);
+    this.rebuild_wasm_views();
+    this.memory_size[0] = size;
+    this.mem8_offset = memory_offset;
     this.mem8 = view(Uint8Array, this.wasm_memory, memory_offset, size);
     this.mem32s = view(
       Uint32Array,
@@ -18883,6 +19848,19 @@ var CPU = class {
           device_bus
         );
       }
+      if (settings.virtio_mem) {
+        const mem_cfg = settings.virtio_mem;
+        this.devices.virtio_mem = new VirtioMem(
+          this,
+          device_bus,
+          mem_cfg.region_addr,
+          mem_cfg.region_size,
+          mem_cfg.block_size
+        );
+      }
+      if (settings.virtio_v86fs) {
+        this.devices.virtio_v86fs = new VirtioV86FS(this, device_bus);
+      }
       this.devices.sb16 = new SB16(this, device_bus);
     }
     if (settings.multiboot) {
@@ -18903,6 +19881,21 @@ var CPU = class {
       }
     }
     this.debug_init();
+    this.rebuild_wasm_views();
+    if (this.mem8_offset > 0) {
+      this.mem8 = view(
+        Uint8Array,
+        this.wasm_memory,
+        this.mem8_offset,
+        this.memory_size[0]
+      );
+      this.mem32s = view(
+        Uint32Array,
+        this.wasm_memory,
+        this.mem8_offset,
+        this.memory_size[0] >> 2
+      );
+    }
   }
   load_multiboot(buffer) {
     if (this.bios.main) {
@@ -19108,7 +20101,6 @@ var CPU = class {
             cpu.write32(multiboot_data + 4, ramdisk_top);
             cpu.write32(multiboot_data + 8, 0);
             cpu.write32(multiboot_data + 12, 0);
-            multiboot_data += 16;
             dbg_assert(ramdisk_top < cpu.memory_size[0]);
             cpu.write_blob(new Uint8Array(initrd), ramdisk_address);
           }
@@ -25182,20 +26174,11 @@ var ServerFileStorageWrapper = class {
 };
 
 // src/browser/starter.ts
-var FileExistsError = class {
-  message;
-  constructor(message) {
-    this.message = message || "File already exists";
-  }
-};
-FileExistsError.prototype = Error.prototype;
-var FileNotFoundError = class {
-  message;
+var FileNotFoundError = class extends Error {
   constructor(message) {
-    this.message = message || "File not found";
+    super(message || "File not found");
   }
 };
-FileNotFoundError.prototype = Error.prototype;
 var V86 = class {
   cpu_is_running = false;
   cpu_exception_hook = function(_n) {
@@ -25223,12 +26206,25 @@ var V86 = class {
     this.bus = bus[0];
     this.emulator_bus = bus[1];
     let cpu;
-    let wasm_memory;
+    const memory_size = options.memory_size || 64 * 1024 * 1024;
+    const vga_memory_size = options.vga_memory_size || 8 * 1024 * 1024;
+    const memory_max = options.memory_max || (memory_size + vga_memory_size) * 4;
+    const WASM_PAGE_SIZE2 = 65536;
+    const wasm_initial_pages = 256;
+    const wasm_max_pages = Math.max(
+      wasm_initial_pages,
+      Math.min(Math.ceil(memory_max / WASM_PAGE_SIZE2), 65536)
+    );
+    const wasm_memory = new WebAssembly.Memory({
+      initial: wasm_initial_pages,
+      maximum: wasm_max_pages
+    });
     const wasm_table = new WebAssembly.Table({
       element: "anyfunc",
       initial: WASM_TABLE_SIZE + WASM_TABLE_OFFSET
     });
     const wasm_shared_funcs = {
+      memory: wasm_memory,
       cpu_exception_hook: (n) => this.cpu_exception_hook(n),
       run_hardware_timers: function(a, t) {
         return cpu.run_hardware_timers(a, t);
@@ -25321,9 +26317,10 @@ var V86 = class {
               "v86.wasm",
               "v86-fallback.wasm"
             );
-          } else if (typeof window === "undefined" && typeof __dirname === "string") {
-            v86_bin = __dirname + "/" + v86_bin;
-            v86_bin_fallback = __dirname + "/" + v86_bin_fallback;
+          } else if (typeof window === "undefined") {
+            const root = new URL("../../", import.meta.url).pathname;
+            v86_bin = root + "build/" + v86_bin;
+            v86_bin_fallback = root + "build/" + v86_bin_fallback;
           } else {
             v86_bin = "build/" + v86_bin;
             v86_bin_fallback = "build/" + v86_bin_fallback;
@@ -25362,11 +26359,11 @@ var V86 = class {
       };
     }
     wasm_fn({ env: wasm_shared_funcs }).then((exports) => {
-      wasm_memory = exports.memory;
       exports["rust_init"]();
       const emulator = this.v86 = new v86(this.emulator_bus, {
         exports,
-        wasm_table
+        wasm_table,
+        wasm_memory
       });
       cpu = emulator.cpu;
       this.continue_init(emulator, options);
@@ -25408,7 +26405,9 @@ var V86 = class {
     settings.mac_address_translation = options.mac_address_translation;
     settings.cpuid_level = options.cpuid_level;
     settings.virtio_balloon = options.virtio_balloon;
+    settings.virtio_mem = options.virtio_mem;
     settings.virtio_console = !!options.virtio_console;
+    settings.virtio_v86fs = !!options.virtio_v86fs;
     const relay_url = options.network_relay_url || options.net_device && options.net_device.relay_url;
     if (relay_url) {
       if (relay_url === "fetch") {
@@ -25886,6 +26885,26 @@ var V86 = class {
   async run() {
     this.v86.run();
   }
+  /**
+   * Grow guest memory to the specified size in bytes. Stops the VM,
+   * grows WASM linear memory, updates memory_size, clears the TLB,
+   * and resumes execution.
+   */
+  async growMemory(newSizeBytes) {
+    const cpu = this.v86.cpu;
+    if (newSizeBytes <= cpu.memory_size[0]) {
+      return;
+    }
+    const wasRunning = this.cpu_is_running;
+    if (wasRunning) {
+      await this.stop();
+    }
+    cpu.resize_memory(newSizeBytes);
+    cpu.full_clear_tlb();
+    if (wasRunning) {
+      await this.run();
+    }
+  }
   /**
    * Stop emulation. Do nothing if emulator is not running. Can be asynchronous.
    */