@ai-ecoverse/slicc-kernel 1.21.1 → 1.22.0

package/dist/kernel-worker.js

@@ -252,6 +252,11 @@ function versionError(theirs) {
 }
 
 // src/fs/types.ts
+function rangedOps(fs) {
+  const { pread, pwrite, truncate } = fs;
+  if (!pread || !pwrite || !truncate) return void 0;
+  return { pread: pread.bind(fs), pwrite: pwrite.bind(fs), truncate: truncate.bind(fs) };
+}
 function fsError(code, path) {
   return Object.assign(new Error(`${code}: ${path}`), { code });
 }
@@ -3654,7 +3659,8 @@ function withCommandDirs(fs, names) {
     symlink: (target, path) => fs.symlink(target, path),
     readlink: (path) => fs.readlink(path),
     chmod: (path, mode) => fs.chmod(path, mode),
-    utimes: (path, atime, mtime) => fs.utimes(path, atime, mtime)
+    utimes: (path, atime, mtime) => fs.utimes(path, atime, mtime),
+    ...rangedOps(fs) ?? {}
   };
 }
 
@@ -3731,6 +3737,11 @@ var FsWatchers = class {
       chmod: after(fs.chmod.bind(fs), (path) => [path]),
       utimes: after(fs.utimes.bind(fs), (path) => [path])
     };
+    const ranged2 = rangedOps(fs);
+    if (ranged2) {
+      overrides.pwrite = after(ranged2.pwrite, (path) => [path]);
+      overrides.truncate = after(ranged2.truncate, (path) => [path]);
+    }
     return new Proxy(fs, {
       get(target, key, receiver) {
         if (Object.hasOwn(overrides, key)) return overrides[key];
@@ -3925,7 +3936,7 @@ var ChildTable = class {
 };
 
 // src/mount/protocol.ts
-var DRIVER_PROTOCOL = [1, 0];
+var DRIVER_PROTOCOL = [1, 1];
 function driverVersionError(theirs) {
   const major = Array.isArray(theirs) ? theirs[0] : void 0;
   if (major === DRIVER_PROTOCOL[0]) return void 0;
@@ -4084,7 +4095,8 @@ function statOf(attr, path, mount) {
     ino: attr.ino ?? inodeOf(path),
     dev: mount.dev,
     ...readonly(mount) ? { readonly: true } : {},
-    ...mount.maxFile > 0 ? { maxFile: mount.maxFile } : {}
+    ...mount.maxFile > 0 ? { maxFile: mount.maxFile } : {},
+    ...mount.caps.ranges ? { ranged: true } : {}
   };
 }
 function concat4(chunks, total) {
@@ -4097,6 +4109,21 @@ function concat4(chunks, total) {
   }
   return out;
 }
+function resized(bytes, size) {
+  if (size <= bytes.length) return bytes.subarray(0, size);
+  const out = new Uint8Array(size);
+  out.set(bytes);
+  return out;
+}
+function handed(bytes, transfer, chunk2) {
+  const whole = bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength;
+  return transfer && whole && bytes.length <= chunk2 && bytes.buffer instanceof ArrayBuffer;
+}
+function spliced(bytes, offset, part) {
+  const out = resized(bytes, Math.max(bytes.length, offset + part.length));
+  out.set(part, offset);
+  return out;
+}
 var MountTable = class {
   mounts = /* @__PURE__ */ new Map();
   devices = 0;
@@ -4376,18 +4403,98 @@ var MountFs = class {
     const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
     try {
       for (let offset = 0; offset < bytes.length; offset += chunk2) {
-        await mount.conn.call({
-          op: "write",
+        const part = bytes.slice(offset, offset + chunk2);
+        await mount.conn.call({ op: "write", fh, offset, bytes: part }, [part.buffer]);
+      }
+    } finally {
+      await mount.conn.call({ op: "release", fh });
+      this.table.forget(mount, real);
+    }
+  }
+  async pread(path, offset, length2) {
+    const real = await this.follow(path);
+    const found = this.at(real);
+    if (!found) return (await this.base.readFileBuffer(real)).slice(offset, offset + length2);
+    const { mount, rel: rel2 } = found;
+    if ((await this.table.getattr(mount, real, rel2)).kind === "directory") {
+      throw errnoError("EISDIR", real);
+    }
+    const fh = await this.open(mount, rel2, false);
+    const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
+    const chunks = [];
+    let total = 0;
+    try {
+      while (total < length2) {
+        const bytes = await mount.conn.call({
+          op: "read",
           fh,
-          offset,
-          bytes: bytes.slice(offset, offset + chunk2)
+          offset: offset + total,
+          size: Math.min(chunk2, length2 - total)
         });
+        if (bytes.length === 0) break;
+        chunks.push(bytes);
+        total += bytes.length;
+      }
+    } finally {
+      await mount.conn.call({ op: "release", fh });
+    }
+    return concat4(chunks, total);
+  }
+  fits(mount, real, end) {
+    if (mount.maxFile > 0 && end > mount.maxFile) {
+      throw errnoError(
+        "EFBIG",
+        `${real} would be larger than this mount's maxfile (${mount.maxFile})`
+      );
+    }
+  }
+  async pwrite(path, offset, bytes, transfer = false) {
+    const real = await this.follow(path, 0, true);
+    const found = this.at(real);
+    if (!found)
+      return this.base.writeFile(
+        real,
+        spliced(await this.base.readFileBuffer(real), offset, bytes)
+      );
+    const { mount, rel: rel2 } = found;
+    this.writable(mount, real);
+    this.fits(mount, real, offset + bytes.length);
+    this.table.forget(mount, real);
+    const fh = await mount.conn.call({
+      op: "open",
+      path: rel2,
+      write: true,
+      create: true,
+      truncate: false,
+      exclusive: false
+    });
+    const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
+    try {
+      for (let at = 0; at < bytes.length; at += chunk2) {
+        const part = handed(bytes, transfer, chunk2) ? bytes : bytes.slice(at, at + chunk2);
+        await mount.conn.call({ op: "write", fh, offset: offset + at, bytes: part }, [part.buffer]);
       }
     } finally {
       await mount.conn.call({ op: "release", fh });
       this.table.forget(mount, real);
     }
   }
+  async truncate(path, size) {
+    const real = await this.follow(path);
+    const found = this.at(real);
+    if (!found?.mount.caps.ranges) {
+      return this.writeFile(real, resized(await this.readFileBuffer(real), size));
+    }
+    const { mount, rel: rel2 } = found;
+    this.writable(mount, real);
+    this.fits(mount, real, size);
+    this.table.forget(mount, real);
+    try {
+      await mount.conn.call({ op: "setattr", path: rel2, size });
+    } finally {
+      this.table.forget(mount, real);
+    }
+  }
   async exists(path) {
     if (!this.at(path)) return this.base.exists(path);
     try {
@@ -4571,7 +4678,8 @@ function statJson(s) {
     ino: s.ino,
     ...s.dev !== void 0 ? { dev: s.dev } : {},
     ...s.readonly ? { readonly: true } : {},
-    ...s.maxFile ? { maxFile: s.maxFile } : {}
+    ...s.maxFile ? { maxFile: s.maxFile } : {},
+    ...s.ranged ? { ranged: true } : {}
   };
 }
 async function readdirStat(fs, dir) {
@@ -4636,10 +4744,24 @@ async function run(entry, path, req) {
     case "utimes":
       await fs.utimes(path, new Date(req.atimeMs ?? 0), new Date(req.mtimeMs ?? 0));
       return done;
+    case "pread":
+    case "pwrite":
+    case "truncate":
+      return ranged(fs, path, req);
     default:
       return { ok: false, errno: "EINVAL", message: `sync-fs: unknown op '${req.op}'` };
   }
 }
+async function ranged(fs, path, req) {
+  const ops = rangedOps(fs);
+  if (!ops) throw syncError("ENOSYS", path);
+  const offset = req.offset ?? 0;
+  if (req.op === "pread")
+    return { ok: true, kind: "bytes", bytes: await ops.pread(path, offset, req.length ?? 0) };
+  if (req.op === "pwrite") await ops.pwrite(path, offset, req.body ?? new Uint8Array(0), true);
+  else await ops.truncate(path, req.length ?? 0);
+  return done;
+}
 async function dispatchSyncFs(req) {
   const entry = resolveSyncFsToken(req.token);
   if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
@@ -5645,6 +5767,226 @@ async function accept(proc, fd, nonblock) {
   return { fd: proc.fds.install(new OpenFile(socket), 3), peer: socket.peer };
 }
 
+// src/fs/pages.ts
+var PAGE = 64 * 1024;
+var READAHEAD = 1024 * 1024;
+var CLEAN_LIMIT = 4 * 1024 * 1024;
+var WRITEBACK = 8 * 1024 * 1024;
+var RUN = 1024 * 1024;
+var Pages = class {
+  length;
+  stored;
+  shrink;
+  pages = /* @__PURE__ */ new Map();
+  dirty = /* @__PURE__ */ new Set();
+  free = [];
+  pinned = false;
+  constructor(size) {
+    this.length = size;
+    this.stored = size;
+  }
+  get dirtyBytes() {
+    return this.dirty.size * PAGE;
+  }
+  get changed() {
+    return this.dirty.size > 0 || this.shrink !== void 0 || this.length !== this.stored;
+  }
+  missing(at, length2) {
+    this.evict();
+    const end = Math.min(this.stored, at + length2, this.length);
+    const runs = [];
+    for (let page = Math.floor(at / PAGE); page * PAGE < end; page++) {
+      if (this.pages.has(page)) continue;
+      const last2 = runs[runs.length - 1];
+      if (last2 && last2[0] + last2[1] === page * PAGE) last2[1] += PAGE;
+      else runs.push([page * PAGE, PAGE]);
+    }
+    const last = runs[runs.length - 1];
+    if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
+    return runs.map(([start, n]) => [start, Math.min(n, this.stored - start)]);
+  }
+  partial(at, length2) {
+    if (length2 === 0) return [];
+    this.evict();
+    const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length2 - 1) / PAGE)]);
+    const runs = [];
+    for (const page of edges) {
+      const start = page * PAGE;
+      const covered = at <= start && at + length2 >= start + PAGE;
+      if (covered || this.pages.has(page) || start >= this.stored) continue;
+      runs.push([start, Math.min(PAGE, this.stored - start)]);
+    }
+    return runs;
+  }
+  fill(start, bytes) {
+    for (let at = 0; at < bytes.length; at += PAGE) {
+      const page = (start + at) / PAGE;
+      if (this.pages.has(page)) continue;
+      const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
+      const fresh = this.take(part.length);
+      fresh.set(part);
+      this.pages.set(page, fresh);
+    }
+  }
+  read(at, length2) {
+    const out = new Uint8Array(Math.max(0, Math.min(this.length, at + length2) - at));
+    this.readInto(at, out);
+    return out;
+  }
+  readInto(at, out) {
+    const end = Math.min(this.length, at + out.length);
+    for (let pos = at; pos < end; ) {
+      const page = Math.floor(pos / PAGE);
+      const from = pos - page * PAGE;
+      const n = Math.min(PAGE - from, end - pos);
+      const bytes = this.pages.get(page);
+      if (bytes) out.set(bytes.subarray(from, from + n), pos - at);
+      else out.fill(0, pos - at, pos - at + n);
+      pos += n;
+    }
+    return Math.max(0, end - at);
+  }
+  write(at, bytes) {
+    for (let done4 = 0; done4 < bytes.length; ) {
+      const pos = at + done4;
+      const page = Math.floor(pos / PAGE);
+      const from = pos - page * PAGE;
+      const n = Math.min(PAGE - from, bytes.length - done4);
+      let target = this.pages.get(page);
+      if (!target) {
+        target = this.take(0);
+        this.pages.set(page, target);
+      }
+      target.set(bytes.subarray(done4, done4 + n), from);
+      this.dirty.add(page);
+      done4 += n;
+    }
+    this.length = Math.max(this.length, at + bytes.length);
+  }
+  truncate(size) {
+    if (size < this.stored) {
+      this.stored = size;
+      this.shrink = Math.min(this.shrink ?? size, size);
+    }
+    if (size < this.length) {
+      const edge = Math.floor(size / PAGE);
+      for (const page of [...this.pages.keys()]) {
+        if (page > edge || page === edge && size === edge * PAGE) this.drop(page);
+      }
+      this.pages.get(edge)?.fill(0, size - edge * PAGE);
+    }
+    this.length = size;
+  }
+  plan() {
+    const runs = [];
+    const sorted = [...this.dirty].sort((a, b) => a - b);
+    for (let i = 0; i < sorted.length; ) {
+      let j = i + 1;
+      const first = sorted[i];
+      while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
+        j++;
+      }
+      const start = first * PAGE;
+      const end = Math.min(this.length, (first + (j - i)) * PAGE);
+      const bytes = new Uint8Array(end - start);
+      for (let k = i; k < j; k++) {
+        const page = this.pages.get(sorted[k]);
+        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start)), (k - i) * PAGE);
+      }
+      runs.push({ offset: start, bytes });
+      i = j;
+    }
+    const written = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
+    return {
+      ...this.shrink !== void 0 ? { shrink: this.shrink } : {},
+      runs,
+      ...this.length > written ? { extend: this.length } : {}
+    };
+  }
+  flushed() {
+    this.dirty.clear();
+    this.shrink = void 0;
+    this.stored = this.length;
+    this.evict();
+  }
+  pin() {
+    this.pinned = true;
+  }
+  reset(size) {
+    if (this.pinned) return;
+    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
+    if (this.changed) return;
+    this.length = size;
+    this.stored = size;
+  }
+  evict() {
+    if (this.pinned) return;
+    let clean = (this.pages.size - this.dirty.size) * PAGE;
+    for (const page of this.pages.keys()) {
+      if (clean <= CLEAN_LIMIT) return;
+      if (this.dirty.has(page)) continue;
+      this.drop(page);
+      clean -= PAGE;
+    }
+  }
+  take(used) {
+    const page = this.free.pop();
+    if (!page) return new Uint8Array(PAGE);
+    page.fill(0, used);
+    return page;
+  }
+  drop(page) {
+    const bytes = this.pages.get(page);
+    this.pages.delete(page);
+    this.dirty.delete(page);
+    if (this.free.length < CLEAN_LIMIT / PAGE) this.free.push(bytes);
+  }
+};
+
+// src/fs/ranged.ts
+var AsyncRangedFile = class {
+  pages;
+  io;
+  pinned = false;
+  path;
+  constructor(io, path, size) {
+    this.io = io;
+    this.path = path;
+    this.pages = new Pages(size);
+  }
+  size() {
+    return this.pages.length;
+  }
+  async fetch(runs) {
+    for (const [start, n] of runs) this.pages.fill(start, await this.io.pread(this.path, start, n));
+  }
+  async read(at, length2) {
+    await this.fetch(this.pages.missing(at, length2));
+    return this.pages.read(at, length2);
+  }
+  async write(at, bytes) {
+    await this.fetch(this.pages.partial(at, bytes.length));
+    this.pages.write(at, bytes);
+    if (!this.pinned && this.pages.dirtyBytes >= WRITEBACK) await this.flush();
+  }
+  truncate(size) {
+    this.pages.truncate(size);
+  }
+  async flush() {
+    if (this.pinned || !this.pages.changed) return;
+    const plan = this.pages.plan();
+    if (plan.shrink !== void 0) await this.io.truncate(this.path, plan.shrink);
+    for (const run2 of plan.runs) await this.io.pwrite(this.path, run2.offset, run2.bytes, true);
+    if (plan.extend !== void 0) await this.io.truncate(this.path, plan.extend);
+    this.pages.flushed();
+  }
+  async pin() {
+    this.pinned = true;
+    this.pages.pin();
+    await this.fetch(this.pages.missing(0, this.pages.length));
+  }
+};
+
 // src/kernel/vfs-file.ts
 var O_ACCMODE = 3;
 var O_WRONLY = 1;
@@ -5664,6 +6006,7 @@ function within3(path, root) {
 }
 var VfsNode = class {
   data;
+  ranged;
   length = 0;
   dirty = false;
   queue = Promise.resolve();
@@ -5694,6 +6037,23 @@ var VfsNode = class {
     clearTimeout(this.writeBack);
     this.writeBack = void 0;
     this.data = void 0;
+    this.ranged = void 0;
+  }
+  async prepare() {
+    if (this.revoked) throw new KernelError("EIO");
+    if (this.ranged || this.data) return this.ranged;
+    const io = rangedOps(this.fs);
+    const st = io && !this.orphaned ? await this.fs.stat?.(this.path).catch(() => void 0) : void 0;
+    if (io && st?.ranged) {
+      this.ranged = new AsyncRangedFile(io, this.path, st.size ?? 0);
+      return this.ranged;
+    }
+    await this.load();
+    return void 0;
+  }
+  async keep() {
+    const ranged2 = await this.prepare();
+    await ranged2?.pin();
   }
   async load() {
     if (this.revoked) throw new KernelError("EIO");
@@ -5710,22 +6070,26 @@ var VfsNode = class {
     return this.data;
   }
   replace(contents2) {
+    this.ranged = void 0;
     this.data = new Uint8Array(contents2);
     this.length = this.data.length;
     this.missing = false;
     this.markDirty();
   }
   async materialize() {
-    await this.load();
+    if (await this.prepare()) return;
     if (!this.missing || this.orphaned) return;
     this.missing = false;
     await this.fs.writeFile(this.path, this.data?.slice(0, this.length) ?? new Uint8Array(0));
+    if (!this.dirty) this.data = void 0;
   }
   async size() {
-    await this.load();
-    return this.length;
+    const ranged2 = await this.prepare();
+    return ranged2 ? ranged2.size() : this.length;
   }
   async pread(max, at) {
+    const ranged2 = await this.prepare();
+    if (ranged2) return ranged2.read(at, max);
     const bytes = await this.load();
     const n = Math.max(0, Math.min(max, this.length - at));
     return bytes.slice(at, at + n);
@@ -5748,12 +6112,18 @@ var VfsNode = class {
   }
   renamedTo(path) {
     this.path = path;
+    if (this.ranged) this.ranged.path = path;
     this.cap = void 0;
   }
   async pwrite(bytes, at) {
     if (bytes.length === 0) return 0;
     await this.fits(at + bytes.length);
-    await this.load();
+    const ranged2 = await this.prepare();
+    if (ranged2) {
+      await ranged2.write(at, bytes);
+      this.markDirty();
+      return bytes.length;
+    }
     const buf = this.ensure(at + bytes.length);
     if (at > this.length) buf.fill(0, this.length, at);
     buf.set(bytes, at);
@@ -5763,7 +6133,12 @@ var VfsNode = class {
   }
   async truncate(size) {
     await this.fits(size);
-    await this.load();
+    const ranged2 = await this.prepare();
+    if (ranged2) {
+      ranged2.truncate(size);
+      this.markDirty();
+      return;
+    }
     const buf = this.ensure(size);
     if (size > this.length) buf.fill(0, this.length, size);
     this.length = size;
@@ -5788,11 +6163,12 @@ var VfsNode = class {
   }
   async flush() {
     if (this.revoked && this.dirty) throw new KernelError("EIO");
-    if (!this.dirty || !this.data || this.orphaned) return;
+    if (!this.dirty || this.orphaned || !(this.data || this.ranged)) return;
     this.dirty = false;
     const started = performance.now();
     try {
-      await this.fs.writeFile(this.path, this.data.slice(0, this.length));
+      if (this.ranged) await this.ranged.flush();
+      else await this.fs.writeFile(this.path, this.data.slice(0, this.length));
     } catch (err) {
       this.dirty = true;
       throw err;
@@ -5839,7 +6215,7 @@ var VfsNodes = class {
   }
   async unlinking(path) {
     const node = this.byPath.get(path);
-    if (node) await node.serial(async () => void await Promise.all([node.load(), node.limit()]));
+    if (node) await node.serial(async () => void await Promise.all([node.keep(), node.limit()]));
   }
   revoke(prefix) {
     for (const [path, node] of this.byPath) {
@@ -6988,7 +7364,8 @@ async function dispatch(h, req) {
     case "setattr":
       return h.setattr?.(req.path, {
         ...req.mode !== void 0 ? { mode: req.mode } : {},
-        ...req.mtime !== void 0 ? { mtime: req.mtime } : {}
+        ...req.mtime !== void 0 ? { mtime: req.mtime } : {},
+        ...req.size !== void 0 ? { size: req.size } : {}
       });
     case "statfs":
       return h.statfs?.() ?? null;
@@ -6996,7 +7373,7 @@ async function dispatch(h, req) {
       throw fsError2("ENOSYS", `unknown driver op ${req.op}`);
   }
 }
-function serveFilesystem(port, handlers, capabilities = {}) {
+function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
   let open = false;
   const reply = (message2, transfer = []) => port.postMessage(message2, transfer);
   async function hello(message2) {
@@ -7032,7 +7409,8 @@ function serveFilesystem(port, handlers, capabilities = {}) {
     dispatch(handlers, data).then(
       (result) => {
         if (result instanceof Uint8Array) {
-          const bytes = result.slice();
+          const whole = result.byteOffset === 0 && result.byteLength === result.buffer.byteLength;
+          const bytes = options.owned && whole ? result : result.slice();
           reply({ id: data.id, result: bytes }, [bytes.buffer]);
         } else reply({ id: data.id, result: result ?? null });
       },
@@ -7698,6 +8076,58 @@ async function openHostfs(spec, hook, fetch2, timing = {}) {
   };
 }
 
+// src/mount/chunked.ts
+var CHUNK2 = 1024 * 1024;
+var ChunkedBytes = class {
+  chunks = [];
+  size = 0;
+  read(offset, length2) {
+    const end = Math.min(this.size, offset + length2);
+    if (end <= offset) return new Uint8Array(0);
+    const out = new Uint8Array(end - offset);
+    for (let at = offset; at < end; ) {
+      const index = Math.floor(at / CHUNK2);
+      const from = at - index * CHUNK2;
+      const n = Math.min(CHUNK2 - from, end - at);
+      const chunk2 = this.chunks[index];
+      if (chunk2) out.set(chunk2.subarray(from, Math.min(from + n, chunk2.length)), at - offset);
+      at += n;
+    }
+    return out;
+  }
+  write(offset, bytes, owned = false) {
+    const whole = owned && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength;
+    for (let done4 = 0; done4 < bytes.length; ) {
+      const at = offset + done4;
+      const index = Math.floor(at / CHUNK2);
+      const from = at - index * CHUNK2;
+      const n = Math.min(CHUNK2 - from, bytes.length - done4);
+      if (whole && n === CHUNK2 && bytes.length === CHUNK2) this.chunks[index] = bytes;
+      else this.room(index, from + n).set(bytes.subarray(done4, done4 + n), from);
+      done4 += n;
+    }
+    this.size = Math.max(this.size, offset + bytes.length);
+  }
+  truncate(size) {
+    if (size < this.size) {
+      const keep = Math.ceil(size / CHUNK2);
+      this.chunks.length = Math.min(this.chunks.length, keep);
+      const tail = this.chunks[keep - 1];
+      const from = size - (keep - 1) * CHUNK2;
+      if (tail && from < tail.length) tail.fill(0, from);
+    }
+    this.size = size;
+  }
+  room(index, need) {
+    const chunk2 = this.chunks[index];
+    if (chunk2 && chunk2.length >= need) return chunk2;
+    const grown = new Uint8Array(Math.min(CHUNK2, Math.max(need, (chunk2?.length ?? 0) * 2)));
+    if (chunk2) grown.set(chunk2);
+    this.chunks[index] = grown;
+    return grown;
+  }
+};
+
 // src/mount/tmpfs.ts
 function tmpfs() {
   let inodes = 0;
@@ -7706,7 +8136,7 @@ function tmpfs() {
     ino: ++inodes,
     mode,
     mtime: Date.now(),
-    data: new Uint8Array(0),
+    data: new ChunkedBytes(),
     target: "",
     children: /* @__PURE__ */ new Map()
   });
@@ -7734,7 +8164,7 @@ function tmpfs() {
   }
   const attr = (node) => ({
     kind: node.kind,
-    size: node.kind === "file" ? node.data.length : node.kind === "symlink" ? node.target.length : 4096,
+    size: node.kind === "file" ? node.data.size : node.kind === "symlink" ? node.target.length : 4096,
     mtime: node.mtime,
     mode: node.mode,
     ino: node.ino
@@ -7769,32 +8199,25 @@ function tmpfs() {
     },
     async open(path, flags) {
       const node = opened2(path, flags);
-      const data = flags.truncate ? new Uint8Array(0) : node.data.slice();
-      handles.set(++nextFh, { node, data, length: data.length, dirty: flags.truncate });
+      if (flags.truncate && node.kind === "file") {
+        node.data.truncate(0);
+        node.mtime = Date.now();
+      }
+      handles.set(++nextFh, { node, write: flags.write });
       return nextFh;
     },
     async read(fh, offset, size) {
-      const h = handle(fh);
-      return h.data.slice(offset, Math.min(h.length, offset + size));
+      return handle(fh).node.data.read(offset, size);
     },
     async write(fh, offset, bytes) {
       const h = handle(fh);
-      const end = offset + bytes.length;
-      if (end > h.data.length) {
-        const grown = new Uint8Array(Math.max(end, h.data.length * 2));
-        grown.set(h.data.subarray(0, h.length));
-        h.data = grown;
-      }
-      h.data.set(bytes, offset);
-      h.length = Math.max(h.length, end);
-      h.dirty = true;
+      if (!h.write) throw fsError2("EBADF", `handle ${fh} is read-only`);
+      h.node.data.write(offset, bytes, true);
+      h.node.mtime = Date.now();
     },
     async release(fh) {
-      const h = handle(fh);
+      handle(fh);
       handles.delete(fh);
-      if (!h.dirty) return;
-      h.node.data = h.data.slice(0, h.length);
-      h.node.mtime = Date.now();
     },
     async mkdir(path) {
       const { dir, name: name2 } = parent(path);
@@ -7847,6 +8270,12 @@ function tmpfs() {
     async setattr(path, change) {
       const node = find(path);
       if (change.mode !== void 0) node.mode = node.mode & ~4095 | change.mode & 4095;
+      if (change.size !== void 0) {
+        if (node.kind !== "file")
+          throw fsError2(node.kind === "directory" ? "EISDIR" : "EINVAL", path);
+        node.data.truncate(change.size);
+        node.mtime = Date.now();
+      }
       if (change.mtime !== void 0) node.mtime = change.mtime;
     },
     async statfs() {
@@ -8437,7 +8866,12 @@ var Launcher = class {
     }
     if (type === "tmpfs") {
       const { port1, port2 } = new MessageChannel();
-      serveFilesystem(port2, tmpfs(), { symlinks: true, chmod: true, attrTtl: 0 });
+      serveFilesystem(
+        port2,
+        tmpfs(),
+        { symlinks: true, chmod: true, ranges: true, attrTtl: 0 },
+        { owned: true }
+      );
       return {
         port: port1,
         dispose: () => {