feat(fs): Node fs parity — node: imports, fs/promises, full method set (#122)

[spacedevin]

Refs #122. Brings tish:fs toward Node fs / fs/promises parity on the bytecode VM (the default tish run backend).

Specifiers (resolver)

• node: prefix is stripped → node:fs / node:fs/promises resolve like the bare forms
• new fs/promises subpath; added the missing bare tty alias

import { readFileSync } from "node:fs"
import { readFile } from "node:fs/promises"

Methods (crates/tish_runtime/src/fs_ext.rs)

One *_core per op + a macro deriving the sync export (value / error-object — tish convention) and the promise export (fulfilled/rejected Promise — Node's fs/promises convention):

readFile/readFileBytes, writeFile, appendFile, exists, stat/lstat (Node-like Stats: isFile()/isDirectory()/size/mtimeMs/…), readdir, mkdir, rm/rmdir/unlink, rename, copyFile/cp, realpath, readlink, truncate, mkdtemp, access, plus constants (F_OK/R_OK/W_OK/X_OK).

Naming

Node names are primary (readFileSync, statSync, existsSync, …); the existing tish names (readFile, readDir, fileExists, isDir) are kept as aliases with their current contracts, so existing code (e.g. scii) is unaffected.

Async

tish:fs/promises exposes the async forms; fs now implies the promise feature (settled-promise machinery). All shipped/CI builds use --features full (already has promise via http), so the feature change is a no-op there.

Tests

Integration fixtures exercise the sync surface via node:fs (write/append/read/stat/mkdir/copy/readdir/rename/rm + constants) and the async surface via node:fs/promises (await + access rejecting on a missing path). Existing readFileBytes test and the full scii suite stay green.

Scope

This PR lands the resolver + VM backend — the default tish run path — with full sync + fs/promises parity. The native codegen (tish build), the interpreter backend, and the Node callback forms get the same surface as follow-ups, tracked in #122.

[codacy-production]

Up to standards ✅

🟢 Issues 0 issues

Results:
0 new issues

View in Codacy

🟢 Metrics 79 complexity · 0 duplication

Metric	Results
Complexity	79
Duplication	0

View in Codacy

🟢 Coverage 56.30% diff coverage · -0.05% coverage variation

Metric	Results
Coverage variation	✅ -0.05% coverage variation (-1.00%)
Diff coverage	✅ 56.30% diff coverage

View coverage diff in Codacy

Coverage variation details

	Coverable lines	Covered lines	Coverage
Common ancestor commit (f7af3ac)	28592	21777	76.16%
Head commit (79ddce3)	28682 (+90)	21832 (+55)	76.12% (-0.05%)

Coverage variation is the difference between the coverage for the head and common ancestor commits of the pull request branch: <coverage of head commit> - <coverage of common ancestor commit>

Diff coverage details

	Coverable lines	Covered lines	Diff coverage
Pull request (#123)	119	67	56.30%

Diff coverage is the percentage of lines that are covered by tests out of the coverable lines that the pull request added or modified: <covered lines added or modified>/<coverable lines added or modified> * 100%

_{NEW Get contextual insights on your PRs based on Codacy's metrics, along with PR and Jira context, without leaving GitHub. Enable AI reviewer
TIP This summary will be updated as you push new changes.}

[github-actions]

Test results

179 tests  +3   179 ✅ +3   8m 20s ⏱️ + 1m 48s
 27 suites +1     0 💤 ±0 
  1 files   ±0     0 ❌ ±0 

Results for commit 79ddce3. ± Comparison against base commit ff7d024.

♻️ This comment has been updated with latest results.

[spacedevin]

Update — extended to all backends. This now covers the full surface on every backend, not just the VM:

• Native codegen (tish build): Node names + new sync methods + a tish:fs/promises module emitted in generated Rust; the await machinery is now emitted for async fs programs (not only http), so await readFile(...) compiles without the HTTP stack. Verified by building + running a native binary that uses node:fs + node:fs/promises.
• Interpreter (--backend interp): bridges to tishlang_runtime::fs_ext via value_convert (eval↔core); core promises convert to eval CorePromise, so fs/promises awaits work on interp too.

fs_parity tests now run the sync and fs/promises fixtures on both vm and interp. The only remaining follow-up tracked in #122 is the Node callback forms (fs.readFile(path, cb)).

[spacedevin]

Callback form added — fs.readFile(path, (err, data) => …), writeFile(path, data, cb), stat(path, cb), etc. The sync functions are now dual: a trailing function arg switches to the Node (err, result) callback form; otherwise they return synchronously (scii's suite stays green — no code reads writeFile's return).

Final backend coverage

form	VM (tish run)	native (tish build)	interp (--backend interp)
sync node:fs	✅	✅	✅
async node:fs/promises	✅	✅	✅
callback fs.x(…, cb)	✅	⚠️	⚠️

⚠️ Callbacks are VM-only for now: native codegen has a pre-existing limitation lowering a multi-arg callback closure passed to a native fn, and the interpreter can't bridge an eval function to a core native. Both are structural (not fs-specific) and tracked in #122. Sync + promises are full on every backend.

Tests: fs_parity now covers sync + promises on both vm/interp and the callback form (with the error path) on vm.

[spacedevin]

Rebased onto current main (was 213 commits behind — Value/ObjectData API era) and modernized:

• Rebased clean onto main; compiles with no API-drift fixes needed (the *_core + macro design ports as-is).
• Passes all modern gates that didn't exist when this was opened: cross-backend parity (interp==vm==node) 95/0, native batch 1/0, the fs_parity integration test 3/0; node:fs sync + fs/promises verified identical across interp/vm/native.
• Security fix: mkdtemp now uses a random base-36 suffix (with exclusive create_dir + collision-retry) instead of a predictable timestamp — the old {prefix}{nanos:x} was predictable (temp-dir symlink/race smell) and collision-prone under rapid calls.
• Confirmed the sync error-object convention still matches modern main (read_file → make_error_value, not a throw), and the boxed byte-array return matches main's existing readFileBytes contract — so no behavior drift.

Ready for review/merge.

[spacedevin]

Callback-form status update (re-tested on the rebased branch):

• Native: the limitation is GONE. readFile(path, (err, data) => …) fires the callback correctly on the native backend — success path ((null, data)) and error path ((errObj, null)), byte-identical to the VM. The codegen work in the ~200 commits since this PR was opened (emit_arrow_function now binds every param via args.get(i)) resolved the multi-arg-closure-to-native-fn lowering. So the "native codegen has a pre-existing limitation" note is stale.
• Interp: still diverges — readFile(path, cb) falls back to the sync form (returns the content; the callback never fires). This is genuinely structural: fs is registered as a self-less Value::Native bridged to core fs_ext, and eval_to_core can't wrap an eval closure as a core value, so the bridge can't invoke the callback. It IS resolvable — the interp already invokes eval callbacks for map/filter/sort via self.call_func (70 call-sites in eval.rs); the fs callback form just needs the same eval-level handling (hook the Value::Native dispatch at eval.rs:3838: match the fs callback fns, run the sync op, split value/error into (err, data), and invoke the callback via self.call_func) instead of the core bridge.

Sync + promises remain full on every backend (interp/vm/native). Net: callbacks now work on VM and native; only the interp callback form is outstanding — a bounded interp change, not a fundamental limit.

[spacedevin]

Interp callback form now works — full parity on every backend.

Fixed the last gap. readFile(path, (err, data) => …), writeFile, stat, … now fire the callback identically on interp / vm / native (success path (null, data) and error path (errObj, null)).

How (interp): a self-less Value::Native bridge can't re-enter the interpreter to invoke an eval callback, so I handled the Node callback convention in call_func's Value::Native arm where &self is available — fsx::callback_core maps the fs native (old alias or fsx bridge, via fn_addr_eq) to its core op, runs it on the non-callback args, splits the Result into (err, data), and calls the callback with self.call_func (the same eval-level path map/filter/sort already use). The fs *_core ops are now pub.

The fs_parity callback test now asserts all three backends (was VM-only). Green: fs_parity 3/0, cross-backend parity 95/0, native batch 1/0. So "sync + promises + callbacks" are now full on every backend.