@ai-ecoverse/slicc-kernel 1.21.1 → 1.22.0

package/dist/process-worker.js

@@ -87,6 +87,249 @@ var init_signals = __esm({
   }
 });
 
+// src/fs/pages.ts
+var PAGE, READAHEAD, CLEAN_LIMIT, WRITEBACK, RUN, Pages;
+var init_pages = __esm({
+  "src/fs/pages.ts"() {
+    "use strict";
+    PAGE = 64 * 1024;
+    READAHEAD = 1024 * 1024;
+    CLEAN_LIMIT = 4 * 1024 * 1024;
+    WRITEBACK = 8 * 1024 * 1024;
+    RUN = 1024 * 1024;
+    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, length) {
+        this.evict();
+        const end = Math.min(this.stored, at + length, 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, length) {
+        if (length === 0) return [];
+        this.evict();
+        const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length - 1) / PAGE)]);
+        const runs = [];
+        for (const page of edges) {
+          const start = page * PAGE;
+          const covered = at <= start && at + length >= 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, length) {
+        const out = new Uint8Array(Math.max(0, Math.min(this.length, at + length) - 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 done = 0; done < bytes.length; ) {
+          const pos = at + done;
+          const page = Math.floor(pos / PAGE);
+          const from = pos - page * PAGE;
+          const n = Math.min(PAGE - from, bytes.length - done);
+          let target = this.pages.get(page);
+          if (!target) {
+            target = this.take(0);
+            this.pages.set(page, target);
+          }
+          target.set(bytes.subarray(done, done + n), from);
+          this.dirty.add(page);
+          done += 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 RangedFile;
+var init_ranged = __esm({
+  "src/fs/ranged.ts"() {
+    "use strict";
+    init_pages();
+    RangedFile = class {
+      pages;
+      io;
+      pinned = false;
+      path;
+      constructor(io, path, size) {
+        this.io = io;
+        this.path = path;
+        this.pages = new Pages(size);
+      }
+      get changed() {
+        return this.pages.changed;
+      }
+      size() {
+        return this.pages.length;
+      }
+      fetch(runs) {
+        for (const [start, n] of runs) this.pages.fill(start, this.io.pread(this.path, start, n));
+      }
+      read(at, length) {
+        this.fetch(this.pages.missing(at, length));
+        return this.pages.read(at, length);
+      }
+      readInto(at, out) {
+        this.fetch(this.pages.missing(at, out.length));
+        return this.pages.readInto(at, out);
+      }
+      write(at, bytes) {
+        this.fetch(this.pages.partial(at, bytes.length));
+        this.pages.write(at, bytes);
+        if (!this.pinned && this.pages.dirtyBytes >= WRITEBACK) this.flush();
+      }
+      truncate(size) {
+        this.pages.truncate(size);
+      }
+      flush() {
+        if (this.pinned || !this.pages.changed) return;
+        const plan = this.pages.plan();
+        if (plan.shrink !== void 0) this.io.truncate(this.path, plan.shrink);
+        for (const run of plan.runs) this.io.pwrite(this.path, run.offset, run.bytes, true);
+        if (plan.extend !== void 0) this.io.truncate(this.path, plan.extend);
+        this.pages.flushed();
+      }
+      pin() {
+        this.pinned = true;
+        this.pages.pin();
+        this.fetch(this.pages.missing(0, this.pages.length));
+      }
+      reset(size) {
+        this.pages.reset(size);
+      }
+    };
+  }
+});
+
 // src/fs/types.ts
 function normalizePath(path) {
   const parts = [];
@@ -171,7 +414,8 @@ function createHelpers(Fs, ops) {
   }
   function statOf(node) {
     if (node.live.orphan) {
-      return { ...node.live.stat, size: node.live.len };
+      const size = node.live.ranged?.size() ?? node.live.len;
+      return { ...node.live.stat, size };
     }
     if (!node.live.stat) {
       const st = call2(() => bridgeOf(node).lstat(liveNodePath(node)));
@@ -192,6 +436,20 @@ function createHelpers(Fs, ops) {
     s.len = bytes.length;
     s.loaded = true;
   }
+  function rangedOf(node) {
+    const s = node.live;
+    if (s.ranged || !s.ranges) return s.ranged;
+    const bridge = bridgeOf(node);
+    const path = () => liveNodePath(node);
+    const io = {
+      pread: (_, at, n) => bridge.pread(path(), at, n),
+      pwrite: (_, at, bytes, transfer) => bridge.pwrite(path(), at, bytes, transfer),
+      truncate: (_, size) => bridge.truncate(path(), size)
+    };
+    const st = call2(() => bridge.stat(path()));
+    s.ranged = new RangedFile(io, path(), st.size);
+    return s.ranged;
+  }
   function ensureCapacity(node, need) {
     const s = node.live;
     const cur = s.data ?? new Uint8Array(0);
@@ -203,9 +461,12 @@ function createHelpers(Fs, ops) {
   }
   function flushNode(node) {
     const s = node.live;
-    if (!s.dirty || !s.data || s.orphan) return;
-    const bytes = s.data.slice(0, s.len);
-    call2(() => bridgeOf(node).writeFile(liveNodePath(node), bytes));
+    if (!s.dirty || s.orphan || !(s.data || s.ranged)) return;
+    if (s.ranged) call2(() => s.ranged?.flush());
+    else {
+      const bytes = s.data.slice(0, s.len);
+      call2(() => bridgeOf(node).writeFile(liveNodePath(node), bytes));
+    }
     s.dirty = false;
     s.stat = void 0;
   }
@@ -218,6 +479,12 @@ function createHelpers(Fs, ops) {
         throw new Fs.ErrnoError(ERRNO_BY_CODE.EFBIG);
       }
     }
+    const ranged = s.openCount > 0 ? rangedOf(node) : void 0;
+    if (ranged) {
+      ranged.truncate(size);
+      s.dirty = true;
+      return;
+    }
     if (s.openCount > 0) {
       if (size > 0) ensureLoaded(node);
       else s.loaded = true;
@@ -228,6 +495,12 @@ function createHelpers(Fs, ops) {
       return;
     }
     const path = liveNodePath(node);
+    const bridge = bridgeOf(node);
+    if (statOf(node).ranged && bridge.truncate) {
+      call2(() => bridge.truncate?.(path, size));
+      s.stat = void 0;
+      return;
+    }
     const bytes = new Uint8Array(size);
     if (size > 0) {
       const cur = call2(() => bridgeOf(node).readFile(path));
@@ -246,6 +519,7 @@ function createHelpers(Fs, ops) {
     childPath,
     ensureLoaded,
     ensureCapacity,
+    rangedOf,
     flushNode,
     truncate
   };
@@ -257,7 +531,7 @@ function createNodeOps(h) {
     getattr(node) {
       const st = statOf(node);
       const s = node.live;
-      const size = Fs.isDir(node.mode) ? 4096 : s.loaded ? s.len : st.size;
+      const size = Fs.isDir(node.mode) ? 4096 : s.ranged?.size() ?? (s.loaded ? s.len : st.size);
       const mtime = new Date(st.mtimeMs ?? 0);
       return {
         dev: st.dev ?? 1,
@@ -357,7 +631,9 @@ function createNodeOps(h) {
       }
       if (open) {
         statOf(open);
-        ensureLoaded(open);
+        const ranged = h.rangedOf(open);
+        if (ranged) ranged.pin();
+        else ensureLoaded(open);
       }
       call2(() => bridgeOf(parent).unlink(childPath(parent, name)));
       if (open) open.live.orphan = true;
@@ -390,7 +666,7 @@ function createNodeOps(h) {
   };
 }
 function createStreamOps(h) {
-  const { Fs, statOf, ensureLoaded, ensureCapacity, flushNode, bridgeOf } = h;
+  const { Fs, statOf, ensureLoaded, ensureCapacity, flushNode, bridgeOf, rangedOf } = h;
   const held = (stream, change) => {
     const s = stream.node.live;
     if ((stream.flags & 3) === 0 || s.orphan) return;
@@ -406,6 +682,11 @@ function createStreamOps(h) {
   return {
     open(stream) {
       if (!Fs.isFile(stream.node.mode)) return;
+      const s = stream.node.live;
+      if (s.openCount === 0 && !s.orphan) {
+        const bridge = bridgeOf(stream.node);
+        s.ranges = !!(bridge.pread && bridge.pwrite && bridge.truncate && statOf(stream.node).ranged);
+      }
       if ((stream.flags & 3) !== 0) {
         try {
           const st = statOf(stream.node);
@@ -437,6 +718,8 @@ function createStreamOps(h) {
         flushNode(node);
       } finally {
         s.data = void 0;
+        s.ranged = void 0;
+        s.ranges = false;
         s.len = 0;
         s.loaded = false;
         held(stream, -1);
@@ -445,6 +728,11 @@ function createStreamOps(h) {
     read(stream, buffer, offset, length, position) {
       const node = stream.node;
       if (Fs.isDir(node.mode)) throw new Fs.ErrnoError(ERRNO_BY_CODE.EISDIR);
+      const ranged = rangedOf(node);
+      if (ranged) {
+        const out2 = new Uint8Array(buffer.buffer, buffer.byteOffset + offset, Math.max(0, length));
+        return h.call(() => ranged.readInto(position, out2));
+      }
       ensureLoaded(node);
       const s = node.live;
       if (position >= s.len || length <= 0) return 0;
@@ -460,6 +748,13 @@ function createStreamOps(h) {
       const s = node.live;
       const end = position + length;
       if (s.maxFile !== void 0 && end > s.maxFile) throw new Fs.ErrnoError(ERRNO_BY_CODE.EFBIG);
+      const ranged = rangedOf(node);
+      if (ranged) {
+        const bytes = new Uint8Array(buffer.buffer, buffer.byteOffset + offset, length);
+        h.call(() => ranged.write(position, bytes));
+        s.dirty = true;
+        return length;
+      }
       ensureLoaded(node);
       const buf = ensureCapacity(node, end);
       if (position > s.len) buf.fill(0, s.len, position);
@@ -473,7 +768,7 @@ function createStreamOps(h) {
       if (whence === SEEK_CUR) pos += stream.position;
       else if (whence === SEEK_END && Fs.isFile(stream.node.mode)) {
         const s = stream.node.live;
-        pos += s.loaded ? s.len : statOf(stream.node).size;
+        pos += rangedOf(stream.node)?.size() ?? (s.loaded ? s.len : statOf(stream.node).size);
       }
       if (pos < 0) throw new Fs.ErrnoError(ERRNO_BY_CODE.EINVAL);
       return pos;
@@ -510,11 +805,15 @@ function ownedBy(plugin, node) {
 function flushLiveVfs(Fs, plugin) {
   for (const head of Fs.nameTable ?? []) {
     for (let node = head; node; node = node.name_next ?? null) {
-      if (!ownedBy(plugin, node) || !node.live.dirty || !node.live.data) continue;
+      const s = node.live;
+      if (!ownedBy(plugin, node) || !s.dirty || !(s.data || s.ranged)) continue;
       try {
-        const bytes = node.live.data.slice(0, node.live.len);
-        node.mount.opts.bridge.writeFile(liveNodePath(node), bytes);
-        node.live.dirty = false;
+        if (s.ranged) s.ranged.flush();
+        else {
+          const bytes = s.data.slice(0, s.len);
+          node.mount.opts.bridge.writeFile(liveNodePath(node), bytes);
+        }
+        s.dirty = false;
       } catch (err) {
         throw toErrno(Fs, err);
       }
@@ -532,8 +831,9 @@ function invalidateLiveVfs(Fs, plugin) {
       s.listed = void 0;
       if (s.openCount === 0) {
         if (node !== node.mount.root && !node.mounted) drop.push(node);
-      } else if (s.loaded && !s.dirty) {
+      } else if (!s.dirty && !s.orphan) {
         s.data = void 0;
+        s.ranged = void 0;
         s.len = 0;
         s.loaded = false;
       }
@@ -652,6 +952,7 @@ var ERRNO_BY_CODE, EIO, S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM,
 var init_live_vfs_fs = __esm({
   "src/realm/live-vfs-fs.ts"() {
     "use strict";
+    init_ranged();
     init_types();
     ERRNO_BY_CODE = {
       EACCES: 2,
@@ -761,7 +1062,8 @@ function parseSyncFsStat(json) {
     ...typeof s.ino === "number" ? { ino: s.ino } : {},
     ...typeof s.dev === "number" ? { dev: s.dev } : {},
     ...s.readonly === true ? { readonly: true } : {},
-    ...typeof s.maxFile === "number" ? { maxFile: s.maxFile } : {}
+    ...typeof s.maxFile === "number" ? { maxFile: s.maxFile } : {},
+    ...s.ranged === true ? { ranged: true } : {}
   };
 }
 var SYNC_FS_REQUEST_TIMEOUT_MS;
@@ -870,7 +1172,7 @@ function createSyncSabTransport(sab, port, deps = {}) {
     }
   }
   return {
-    call(req, timeoutMs, label) {
+    call(req, timeoutMs, label, transfer = []) {
       if (deps.memory) publishMemory(sab, deps.memory());
       const id = ++seq;
       const deadline = now() + timeoutMs;
@@ -883,7 +1185,8 @@ function createSyncSabTransport(sab, port, deps = {}) {
           Atomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
           const msg = offset === 0 ? { type: SYNC_SAB_REQ_MSG, id, req } : { type: SYNC_SAB_NEXT_MSG, id, offset };
           try {
-            port.postMessage(msg);
+            if (offset === 0 && transfer.length > 0) port.postMessage(msg, transfer);
+            else port.postMessage(msg);
           } catch {
             throw syncError("EIO", label);
           }
@@ -916,8 +1219,8 @@ function errnoError(code2, path) {
 }
 function createSyncFsSabBridge(transport, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? SYNC_FS_REQUEST_TIMEOUT_MS;
-  function run(req, path) {
-    const result = transport.call(req, timeoutMs, `sync-sab bridge, '${path}'`);
+  function run(req, path, transfer) {
+    const result = transport.call(req, timeoutMs, `sync-sab bridge, '${path}'`, transfer);
     if (!result.ok) throw errnoError(result.errno, path);
     return result;
   }
@@ -1001,7 +1304,16 @@ function createSyncFsSabBridge(transport, opts = {}) {
     hold: (path, held) => {
       run({ op: "hold", path, mode: held ? 1 : 0 }, path);
     },
-    statfs: (path = "/") => parseSyncFsUsage(json({ op: "statfs", path }, path))
+    statfs: (path = "/") => parseSyncFsUsage(json({ op: "statfs", path }, path)),
+    pread: (path, offset, length) => bytes({ op: "pread", path, offset, length }, path),
+    pwrite: (path, offset, body, transfer) => {
+      const whole = body.byteOffset === 0 && body.byteLength === body.buffer.byteLength;
+      const owned = transfer && whole && body.buffer instanceof ArrayBuffer;
+      run({ op: "pwrite", path, offset, body }, path, owned ? [body.buffer] : []);
+    },
+    truncate: (path, length) => {
+      run({ op: "truncate", path, length }, path);
+    }
   };
 }
 var init_sync_sab_bridge = __esm({
@@ -3468,6 +3780,11 @@ function cachingBridge(bridge, now = () => performance.now()) {
     symlink: (target, link) => mutating(() => bridge.symlink(target, link)),
     chmod: (p, mode) => mutating(() => bridge.chmod(p, mode)),
     utimes: (p, a, m) => mutating(() => bridge.utimes(p, a, m)),
+    ...bridge.pread && bridge.pwrite && bridge.truncate ? {
+      pread: bridge.pread.bind(bridge),
+      pwrite: (p, at, bytes, transfer) => mutating(() => bridge.pwrite?.(p, at, bytes, transfer)),
+      truncate: (p, size) => mutating(() => bridge.truncate?.(p, size))
+    } : {},
     invalidate
   };
 }
@@ -3475,6 +3792,7 @@ var WasiError, FileBuffer, LocalFile, MISS_TTL_MS;
 var init_wasi_files = __esm({
   "src/process/wasi/wasi-files.ts"() {
     "use strict";
+    init_ranged();
     WasiError = class extends Error {
       code;
       constructor(code2) {
@@ -3489,17 +3807,37 @@ var init_wasi_files = __esm({
       orphaned = false;
       opens = 0;
       fs;
-      path;
+      where;
+      ranged;
       maxFile;
-      constructor(fs, path, empty, maxFile) {
+      constructor(fs, path, empty, maxFile, size) {
         this.fs = fs;
-        this.path = path;
+        this.where = path;
         this.maxFile = maxFile;
-        if (empty) {
+        const { pread, pwrite, truncate } = fs;
+        if (size !== void 0 && pread && pwrite && truncate) {
+          const io = { pread: pread.bind(fs), pwrite: pwrite.bind(fs), truncate: truncate.bind(fs) };
+          this.ranged = new RangedFile(io, path, size);
+          if (empty) this.truncate(0);
+        } else if (empty) {
           this.data = new Uint8Array(0);
           this.dirty = true;
         }
       }
+      get path() {
+        return this.where;
+      }
+      set path(path) {
+        this.where = path;
+        if (this.ranged) this.ranged.path = path;
+      }
+      get isRanged() {
+        return this.ranged !== void 0;
+      }
+      keep() {
+        if (this.ranged) this.ranged.pin();
+        else this.load();
+      }
       load() {
         if (!this.data) {
           this.data = this.fs.readFile(this.path);
@@ -3508,10 +3846,12 @@ var init_wasi_files = __esm({
         return this.data;
       }
       size() {
+        if (this.ranged) return this.ranged.size();
         this.load();
         return this.length;
       }
       pread(max, at) {
+        if (this.ranged) return this.ranged.read(at, max);
         const bytes = this.load();
         const n = Math.max(0, Math.min(max, this.length - at));
         return bytes.subarray(at, at + n);
@@ -3523,22 +3863,30 @@ var init_wasi_files = __esm({
         if (bytes.length === 0) return 0;
         const end = at + bytes.length;
         this.fits(end);
+        this.dirty = true;
+        if (this.ranged) {
+          this.ranged.write(at, bytes);
+          return bytes.length;
+        }
         this.load();
         this.ensure(end);
         const buf = this.data;
         if (at > this.length) buf.fill(0, this.length, at);
         buf.set(bytes, at);
         this.length = Math.max(this.length, end);
-        this.dirty = true;
         return bytes.length;
       }
       truncate(size) {
         this.fits(size);
+        this.dirty = true;
+        if (this.ranged) {
+          this.ranged.truncate(size);
+          return;
+        }
         this.load();
         this.ensure(size);
         if (size > this.length) this.data.fill(0, this.length, size);
         this.length = size;
-        this.dirty = true;
       }
       ensure(need) {
         const cur = this.data;
@@ -3549,6 +3897,7 @@ var init_wasi_files = __esm({
       }
       orphan() {
         this.orphaned = true;
+        this.ranged?.pin();
       }
       isOrphan() {
         return this.orphaned;
@@ -3557,11 +3906,14 @@ var init_wasi_files = __esm({
         return this.dirty;
       }
       contents() {
+        if (this.ranged) return this.ranged.read(0, this.ranged.size());
         return this.load().slice(0, this.length);
       }
       flush() {
-        if (this.orphaned || !this.dirty || !this.data) return;
-        this.fs.writeFile(this.path, this.data.slice(0, this.length));
+        if (this.orphaned || !this.dirty) return;
+        if (this.ranged) this.ranged.flush();
+        else if (this.data) this.fs.writeFile(this.path, this.data.slice(0, this.length));
+        else return;
         this.dirty = false;
       }
     };
@@ -3771,7 +4123,8 @@ function openAccess(existing, oflags, rights) {
 }
 function promoteRequest(fd, f, handed) {
   const orphan = f.buffer.isOrphan();
-  const joins = !orphan && handed.has(f.buffer);
+  if (!orphan && f.buffer.isRanged) f.buffer.flush();
+  const joins = !orphan && (handed.has(f.buffer) || f.buffer.isRanged);
   return {
     op: "fd-promote",
     fd,
@@ -4113,7 +4466,7 @@ var init_wasi_fds = __esm({
         if (this.shared) this.kernel.call({ op: "fd-path-flush", path });
       }
       unlinking(path) {
-        this.buffers.get(path)?.load();
+        this.buffers.get(path)?.keep();
         if (this.shared) this.kernel.call({ op: "fd-path-unlinking", path });
       }
       unlinked(path) {
@@ -4174,7 +4527,8 @@ var init_wasi_fds = __esm({
         } else {
           if (!existing) this.fs.writeFile(path, new Uint8Array(0));
           const empty = !existing || (oflags & OFLAGS.TRUNC) !== 0;
-          buffer = new FileBuffer(this.fs, path, empty, (existing ?? this.fs.stat(path)).maxFile);
+          const st = existing ?? this.fs.stat(path);
+          buffer = new FileBuffer(this.fs, path, empty, st.maxFile, st.ranged ? st.size : void 0);
           this.buffers.set(path, buffer);
         }
         buffer.opens++;
@@ -5486,7 +5840,7 @@ function align(n, to) {
   return Math.ceil(n / to) * to;
 }
 function growTo(memory, bytes) {
-  const pages2 = Math.ceil(bytes / PAGE) - memory.buffer.byteLength / PAGE;
+  const pages2 = Math.ceil(bytes / PAGE2) - memory.buffer.byteLength / PAGE2;
   if (pages2 > 0) memory.grow(pages2);
 }
 function growTable(table, length) {
@@ -5496,14 +5850,14 @@ function call(instance, name) {
   const fn = instance.exports[name];
   if (typeof fn === "function") fn();
 }
-var TABLE_BASE, PAGE, STACK_SIZE, LIBRARY_DIRS, DlError, WasixLinker;
+var TABLE_BASE, PAGE2, STACK_SIZE, LIBRARY_DIRS, DlError, WasixLinker;
 var init_wasix_linker = __esm({
   "src/process/wasi/wasix-linker.ts"() {
     "use strict";
     init_dylink();
     init_wasi_files();
     TABLE_BASE = 1;
-    PAGE = 65536;
+    PAGE2 = 65536;
     STACK_SIZE = 8 * 1024 * 1024;
     LIBRARY_DIRS = ["/lib", "/usr/lib", "/usr/local/lib"];
     DlError = class extends Error {