@aptre/v86 0.5.0 → 0.6.1

package/dist/v86.browser.js

@@ -142,6 +142,7 @@ var V86Starter = (() => {
   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;
@@ -5456,17 +5457,18 @@ var V86Starter = (() => {
                   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();
               }
             }
@@ -5703,7 +5705,7 @@ var V86Starter = (() => {
     // 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;
@@ -6924,7 +6926,7 @@ var V86Starter = (() => {
         (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;
@@ -7030,6 +7032,7 @@ var V86Starter = (() => {
           0,
           0,
           0,
+          0,
           PAM0,
           0,
           0,
@@ -7342,7 +7345,11 @@ var V86Starter = (() => {
       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);
@@ -7993,7 +8000,7 @@ var V86Starter = (() => {
           break;
         case 254:
           dbg_log("CPU reboot via PS2");
-          this.cpu.reboot_internal();
+          this.cpu.reboot();
           break;
         default:
           dbg_log(
@@ -15138,12 +15145,930 @@ var V86Starter = (() => {
     }
   };
 
+  // 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;
@@ -15236,11 +16161,11 @@ var V86Starter = (() => {
     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];
@@ -15263,14 +16188,14 @@ var V86Starter = (() => {
     }
     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) {
         ;
@@ -15339,7 +16264,7 @@ var V86Starter = (() => {
       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]);
         }
       }
@@ -15390,15 +16315,15 @@ var V86Starter = (() => {
       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) {
@@ -15570,13 +16495,13 @@ var V86Starter = (() => {
         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;
@@ -15594,8 +16519,8 @@ var V86Starter = (() => {
       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;
@@ -15636,9 +16561,9 @@ var V86Starter = (() => {
       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;
     }
@@ -15683,7 +16608,7 @@ var V86Starter = (() => {
       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);
       }
     }
@@ -16038,7 +16963,7 @@ var V86Starter = (() => {
       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]);
@@ -16104,13 +17029,13 @@ var V86Starter = (() => {
     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(
@@ -16214,7 +17139,7 @@ var V86Starter = (() => {
       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];
@@ -16744,7 +17669,7 @@ var V86Starter = (() => {
       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) {
@@ -16805,7 +17730,7 @@ var V86Starter = (() => {
             name
           );
           if (ret < 0) {
-            let error_message = "";
+            let error_message;
             if (ret === -EPERM)
               error_message = "Operation not permitted";
             else {
@@ -16918,7 +17843,7 @@ var V86Starter = (() => {
             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);
@@ -16949,7 +17874,7 @@ var V86Starter = (() => {
           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],
@@ -17274,7 +18199,7 @@ var V86Starter = (() => {
             newname
           );
           if (ret < 0) {
-            let error_message = "";
+            let error_message;
             if (ret === -ENOENT)
               error_message = "No such file or directory";
             else if (ret === -EPERM)
@@ -17323,7 +18248,7 @@ var V86Starter = (() => {
           }
           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)
@@ -17897,6 +18822,7 @@ var V86Starter = (() => {
     wasm_memory;
     memory_size;
     mem8;
+    mem8_offset = 0;
     mem32s;
     segment_is_null;
     segment_offsets;
@@ -17975,7 +18901,6 @@ var V86Starter = (() => {
     get_eflags;
     handle_irqs;
     main_loop;
-    reboot_internal;
     set_jit_config;
     read8;
     read16;
@@ -18024,13 +18949,49 @@ var V86Starter = (() => {
       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);
@@ -18059,40 +19020,22 @@ var V86Starter = (() => {
       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);
@@ -18100,16 +19043,6 @@ var V86Starter = (() => {
       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);
@@ -18172,7 +19105,7 @@ var V86Starter = (() => {
     }
     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;
@@ -18193,7 +19126,6 @@ var V86Starter = (() => {
       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");
@@ -18350,6 +19282,8 @@ var V86Starter = (() => {
       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() {
@@ -18410,8 +19344,33 @@ var V86Starter = (() => {
         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]
@@ -18509,6 +19468,10 @@ var V86Starter = (() => {
         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];
@@ -18707,8 +19670,10 @@ var V86Starter = (() => {
         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,
@@ -18919,6 +19884,19 @@ var V86Starter = (() => {
             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) {
@@ -18939,6 +19917,21 @@ var V86Starter = (() => {
         }
       }
       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) {
@@ -19144,7 +20137,6 @@ var V86Starter = (() => {
               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);
             }
@@ -25218,20 +26210,12 @@ ${e.stack || e.message}`
   };
 
   // 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 import_meta = {};
+  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) {
@@ -25259,12 +26243,25 @@ ${e.stack || e.message}`
       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);
@@ -25357,9 +26354,10 @@ ${e.stack || e.message}`
                 "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;
@@ -25398,11 +26396,11 @@ ${e.stack || e.message}`
         };
       }
       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);
@@ -25444,7 +26442,9 @@ ${e.stack || e.message}`
       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") {
@@ -25922,6 +26922,26 @@ ${e.stack || e.message}`
     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.
      */