Best way to redirect vfs writes to real fs in when using sea

[spotandjake]

I am working on switching an app from using the older pkg builder to the node-sea builder, and previously I had been using:

if (process.pkg) {
  const fs = require("fs");
  const path = require("path");
  const stdlibPath = require("@grain/stdlib");
  const stdlibPathWithTrailingSep = `${stdlibPath}${path.sep}`;
  // From https://github.com/sindresorhus/escape-string-regexp/blob/main/index.js
  const regexpSafeStdlibPath = stdlibPathWithTrailingSep
    .replace(/[|\\{}()[\]^$+*?.]/g, "\\$&")
    .replace(/-/g, "\\x2d");

  const stdlibTarget = path.join(process.cwd(), "/target");

  try {
    fs.mkdirSync(stdlibTarget, { recursive: true });
  } catch (err) {
    console.error(`Unable to create directory: ${stdlibTarget}`, err);
    process.exit(1);
  }

  process.pkg.mount(
    new RegExp(`${regexpSafeStdlibPath}(.+)(?<!.gr)$`),
    function (_match, group1) {
      return path.join(stdlibTarget, group1);
    },
  );
}

To redirect writes to the vfs to the disk while keeping reads on the vfs, is there anyway for me to keep this behaviour with the newer vfs?.

[robertsLando]

process.pkg.mount only exists in classic mode — it's installed by prelude/bootstrap.js, and the SEA prelude never sets it. So there's no direct equivalent today.

The good news is you probably don't need one. In SEA mode the VFS (@roberts_lando/vfs) only intercepts read-side fs calls (readFile*, stat, lstat, readdir, readlink, realpath, access, exists, createReadStream, watch, + the fs.promises equivalents), and only when the path actually exists in the archive. Everything else goes straight to the real fs. Quick check with a --sea build:

mode pkg mount? undefined
read .gr -> module List                 # served from the snapshot
raw write to snapshot: ENOENT: no such file or directory, open '/snapshot/app/stdlib/list.wasm'
read missing from snapshot: ENOENT      # fell through to the real fs, which has no /snapshot

So writes aren't "trapped in the VFS" — they just target a path that doesn't exist on disk. All you need is the path rewrite itself, which you can install in userland: your code runs after the VFS has patched fs, so your wrapper sits on top and the rewritten (real) path never reaches the VFS.

if (process.pkg && !process.pkg.mount) {
  const fs = require('fs');
  const path = require('path');
  const stdlib = require('@grain/stdlib');
  const target = path.join(process.cwd(), 'target');
  fs.mkdirSync(target, { recursive: true });

  const prefix = stdlib + path.sep;
  const esc = prefix.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
  const rule = new RegExp(`^${esc}(.+)(?<!\\.gr)$`);   // same rule as your mount()

  const remap = (p) => {
    if (typeof p !== 'string') return p;
    const m = rule.exec(p);
    return m ? path.join(target, m[1]) : p;
  };

  const ONE = ['readFileSync','readFile','writeFileSync','writeFile','appendFileSync','appendFile',
    'openSync','open','statSync','stat','lstatSync','lstat','readdirSync','readdir','existsSync',
    'accessSync','access','mkdirSync','mkdir','rmSync','rm','unlinkSync','unlink','realpathSync',
    'realpath','createReadStream','createWriteStream'];
  const TWO = ['renameSync','rename','copyFileSync','copyFile'];

  for (const api of [fs, fs.promises]) {   // require('fs/promises') is the same object as fs.promises
    for (const name of ONE) {
      const orig = api[name];
      if (typeof orig !== 'function') continue;
      api[name] = function (p, ...rest) { return orig.call(api, remap(p), ...rest); };
    }
    for (const name of TWO) {
      const orig = api[name];
      if (typeof orig !== 'function') continue;
      api[name] = function (a, b, ...rest) { return orig.call(api, remap(a), remap(b), ...rest); };
    }
  }
}

Verified in a --sea binary: .gr files still come from the snapshot, everything else reads and writes through to <cwd>/target/:

read .gr -> module List
write .wasm -> ok, read back: BINARY
on disk: true

Two caveats: run this before anything caches a destructured reference (const { readFileSync } = require('fs')), and it only covers fs — not require/import of remapped paths, which shouldn't matter for .wasm output.

If a first-class process.pkg.mount in SEA mode would be useful to more people, open an issue and I'll look at it — it would have to live in the pkg SEAProvider for reads plus a write-side rewrite, since the VFS itself doesn't intercept writes at all.