@amritk/nish-aarch64-darwin 0.25.0 → 0.27.2

package/docs/AI.md

@@ -2137,11 +2137,18 @@ a `\u` escape `nish/json` decodes) is one unit per byte, and counts its bytes.
 it is; `i32`: the length, or a negative errno), `renameSync(from, to)` (`0` or
 a negative errno; atomic on one filesystem, `-18` across two, so write the
 temporary beside the target), `unlinkSync(path)` (`0` or a negative errno; a
-directory is refused), `writeBytes(bytes, off, len)` (a `u8[]` range to stdout
+directory is refused), `writeFileSyncMode(path, data, mode)` (the file left
+at exactly `mode` (`0..0o777`), set before the first byte, written in place; a symbolic link refused; the
+length or a negative errno), `createFileExclusiveSync(path, data, mode)` (the
+same, but `-17` when the name exists: a lock file), `mkdirSyncMode(path, mode)`
+(`0`, `-17` when it exists, the umask applies), `writeBytes(bytes, off, len)` (a `u8[]` range to stdout
 as it is, the length or a negative errno; the range panics like
 `netWrite`'s), `mkdirSync(path)` (one level, `boolean`),
 `isDirectorySync(path)`, `readdirSync(path)` (`string[] | null`, sorted by
 bytes, no `.`/`..`), `spawnSync(argv)`, `spawnSyncTo(argv, outPath, errPath)`,
+`spawnPiped(argv, stdin, stdout, stderr)` (stdin from a `u8[]`, both outputs
+appended to `u8[]`s, the status; `-2` past 16 MiB; the way to hand a child a
+secret, never argv or the environment),
 `getenv(name)` (`string | null` — unset and empty are different answers),
 `realpathSync(path)` (`string | null`; symbolic links resolved, absolute, and
 `null` when it does not resolve),
@@ -2174,8 +2181,9 @@ also watches the signal fd. None of `spawn`, `kill`, `waitPid` may be called in
 a task or a parallel body; the two host facts may. `availableParallelism()` (`i32`, at least 1, no `--threads` needed) and
 `totalMemory()` (`i64` bytes, or `-1`) size a program to the machine. None of
 the five exists on a wasm target, and `spawn` and `waitPid` throw under Node.
-`setNice(n)` sets the nice value (clamped to -20..19; lowering it unprivileged
-is `-13`) and `setIdlePriority()` moves the program to Linux's `SCHED_IDLE`
+`setNice(n)` sets the nice value, and it is lower-only even as root: `n` takes
+0..19 (`-22` outside it) and a value below the current one is `-13`, with no
+system call either way. `setIdlePriority()` moves the program to Linux's `SCHED_IDLE`
 (`-95` on Darwin); each answers 0 or a negative errno. Call them at the top of
 `main`, never in a task. An unprivileged process can never leave `SCHED_IDLE`
 and an idle one can starve on a saturated machine, so keep a normal-priority
@@ -2194,6 +2202,10 @@ wait for it to be writable, then `connectResult(fd)` is 0 or the failure. Buffer
 are `u8[]` only; an address is 18 bytes of one (IPv4 as `::ffff:a.b.c.d`, then
 the port big-endian); hosts are numeric literals; to reach a name, resolve it first with
 `nish/net/dns` (`DnsClient` on your loop, or the blocking `resolveHost`).
+To fetch a URL from a CLI, skip all of this: `nish/net/http-client`'s
+`httpFetch(new HttpRequest("GET", url), new HttpOptions())` blocks until the
+response's head is in and answers it with `body.readAll(limit)`, or null on a
+failure (an `HttpClient` keeps the connection and says why in `error`).
 `netRead` / `netWrite` panic on a range outside the buffer.
 `tcpListenFlags(host, port, backlog, flags)` is `tcpListen` with flag 1
 `SO_REUSEPORT`, so several listeners, in one process or many, share a port (Linux
@@ -2625,6 +2637,20 @@ the array open: end it and send the rest in the next statement. Every other
 guide's [PostgreSQL page](guide/using-nish/postgres.md#array-parameters) its
 walk-through.)
 
+**Read PostgreSQL ids, counts and times without parsing them** — there is no
+driver option for binary results: in `nish/net/postgres`, open the bind with
+`bindStartBinary(name)` instead of `bindStart(name)`, and every result column
+of that execution comes in binary. Read an `int2`/`int4`/`int8` with
+`binaryInt(c)`, a `bool` with `binaryBool(c)`, a `float8` with
+`binaryFloat(c)`, a `timestamptz` with `conn.binary.timestamp(conn.inputBuffer(),
+conn.colStart(c), conn.colLength(c), out, at)` (or its microseconds since 2000
+with `binaryInt(c)`, written out by `conn.binary.iso(micros, out, at)`), and a
+`text` column with `columnText(c)` as before. Cast anything else (`numeric`,
+`text[]`) to `text` in the SQL. (No block, as for `nish/text`;
+`tests/postgres/live`'s `binary` scenario runs it against a server, and the
+user guide's [PostgreSQL page](guide/using-nish/postgres.md#binary-results)
+its walk-through.)
+
 **Batch a server's keyed reads into one PostgreSQL query** — there is no
 DataLoader and no `setTimeout` to collect a tick's keys: in `nish/net/postgres`,
 a `PgBatcher` built from a `PgBatchConfig` (`name`, `select` reading the key as
@@ -2633,7 +2659,7 @@ a `PgBatcher` built from a `PgBatchConfig` (`name`, `select` reading the key as
 queue is full, or for a text key too long for `maxBytes`, with no room left in
 `queueBytes`, with a NUL or not UTF-8 — and `take(conn)`
 binds the waiting ones, each key once, as one execution of its `sql` over
-`unnest($1) with ordinality`, answering a run handle or -1. Hand that
+`unnest($1) with ordinality`, answering a run handle or -1. Set `binary` in the `PgBatchConfig` and each batch comes in binary: `take` opens its bind with `bindStartBinary`, and `row` reads the routing ordinal with `binaryInt` (`binary.failed` is saved and restored, so the caller's own decoding is untouched). Hand that
 execution's `PG_ROW` to `row(run, conn)`, `PG_COMPLETE` to `end(run)`, an error
 or `PG_LOST` to `fail(run)` (on a spent handle these do nothing and count in
 `stray`), and after each call `next(run)` until

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/nish-aarch64-darwin",
-  "version": "0.25.0",
+  "version": "0.27.2",
   "description": "The nish native compiler for macOS on ARM64",
   "license": "MIT",
   "os": [

package/runtime/core/host.d.ts

@@ -47,6 +47,9 @@ export declare function appendFileSync(path: string, data: string): void;
 export declare function writeFileBytesSync(path: string, bytes: readonly u8[]): i32;
 export declare function renameSync(from: string, to: string): i32;
 export declare function unlinkSync(path: string): i32;
+export declare function writeFileSyncMode(path: string, data: string, mode: i32): i32;
+export declare function createFileExclusiveSync(path: string, data: string, mode: i32): i32;
+export declare function mkdirSyncMode(path: string, mode: i32): i32;
 export declare function mkdirSync(path: string): boolean;
 export declare function isDirectorySync(path: string): boolean;
 export declare function readdirSync(path: string): string[] | null;
@@ -56,6 +59,7 @@ export declare function arch(): string;
 export declare function getenv(name: string): string | null;
 export declare function spawnSync(argv: string[]): number;
 export declare function spawnSyncTo(argv: string[], stdoutPath: string, stderrPath: string): number;
+export declare function spawnPiped(argv: string[], stdin: readonly u8[], stdout: u8[], stderr: u8[]): i32;
 export declare function kill(pid: i32, sig: i32): i32;
 export declare function availableParallelism(): i32;
 export declare function totalMemory(): i64;

package/runtime/core/host.mjs

@@ -157,6 +157,18 @@ export function unlinkSync(path) {
   return host.call("unlinkSync", [path]);
 }
 
+export function writeFileSyncMode(path, data, mode) {
+  return host.call("writeFileSyncMode", [path, data, mode]);
+}
+
+export function createFileExclusiveSync(path, data, mode) {
+  return host.call("createFileExclusiveSync", [path, data, mode]);
+}
+
+export function mkdirSyncMode(path, mode) {
+  return host.call("mkdirSyncMode", [path, mode]);
+}
+
 export function mkdirSync(path) {
   return host.call("mkdirSync", [path]);
 }
@@ -193,6 +205,18 @@ export function spawnSyncTo(argv, out, err) {
   return host.call("spawnSyncTo", [argv, out, err]);
 }
 
+/**
+ * `spawnPiped(argv, stdin, stdout, stderr)`: the host runs the child and hands
+ * back its status and both streams' bytes, and they are appended here, as the
+ * runtime appends them to the caller's arrays.
+ */
+export function spawnPiped(argv, input, out, err) {
+  const [status, outBytes, errBytes] = host.call("spawnPiped", [argv, input]);
+  for (const b of outBytes) out.push(b);
+  for (const b of errBytes) err.push(b);
+  return status;
+}
+
 export function kill(pid, sig) {
   return host.call("kill", [pid, sig]);
 }

package/runtime/nish.d.ts

@@ -276,6 +276,33 @@ declare function writeFileBytesSync(path: string, bytes: readonly u8[]): i32;
 declare function renameSync(from: string, to: string): i32;
 /** The name `path` removed: 0, or a negative errno. A directory is refused, not removed. */
 declare function unlinkSync(path: string): i32;
+/**
+ * `writeFileSync` with an explicit `mode`: the file is exactly `mode`
+ * (`0o600` for a secret) before a byte of `data` is in it, whatever the umask
+ * or a file already there had, and a symbolic link at the path is refused
+ * (-40). The byte count, or a negative errno: -22 for a mode outside
+ * 0..0o777, the setuid, setgid and sticky bits included. The file is
+ * truncated and written in place, so a crash or a failed write leaves it
+ * empty or partial, and a file this process may write but does not own is
+ * emptied before the mode change answers -1 (`EPERM`). For a file that must
+ * be the old one or the new one, write a temporary name with this and move it
+ * with `renameSync`. Never an exit.
+ */
+declare function writeFileSyncMode(path: string, data: string, mode: i32): i32;
+/**
+ * `data` in a new file of exactly `mode`, created only if nothing is at `path`:
+ * -17 when something is, a dangling symbolic link included. Of several
+ * processes racing for one path exactly one succeeds, so it takes a lock. The
+ * byte count, or a negative errno; a write that fails after the create
+ * removes the file, so the lock is not left taken. Never an exit.
+ */
+declare function createFileExclusiveSync(path: string, data: string, mode: i32): i32;
+/**
+ * One directory made with `mode` less the umask (`0o700` is exact under any
+ * umask that leaves the owner's bits): 0, or a negative errno. A path already
+ * there is -17 and its mode is not changed; -22 for a mode outside 0..0o777.
+ */
+declare function mkdirSyncMode(path: string, mode: i32): i32;
 /** One directory, not recursive; whether a directory is there afterwards. */
 declare function mkdirSync(path: string): boolean;
 /** Whether a directory is at `path` right now. One `stat`, and never an exit. */
@@ -299,6 +326,13 @@ declare function spawnSync(argv: string[]): number;
  * either path is refused, as `writeFileSync` refuses one, and the answer is -1.
  */
 declare function spawnSyncTo(argv: string[], stdoutPath: string, stderrPath: string): number;
+/**
+ * The same run with all three streams on pipes: `stdin` is written to the
+ * child and closed, and what it prints is appended to `stdout` and `stderr`.
+ * The status as `spawnSync` answers it, or -2 when a stream passed 16 MiB:
+ * the child is then killed and each array keeps at most the first 16 MiB.
+ */
+declare function spawnPiped(argv: string[], stdin: readonly u8[], stdout: u8[], stderr: u8[]): i32;
 /**
  * Start `argv[0]` through `PATH` without waiting: the child's pid, or a
  * negative errno. The child is the program's until `waitPid` reaps it. No
@@ -322,10 +356,10 @@ declare function availableParallelism(): i32;
 /** Bytes of physical memory, or -1 when the host does not say. */
 declare function totalMemory(): i64;
 /**
- * Set this process's nice value to `n`: 0, or a negative errno. The kernel
- * clamps `n` to -20..19, and lowering it below the current value needs the
- * privilege to (-13 without it on Linux). Children started afterwards inherit
- * it. Throws under Node.
+ * Set this process's nice value to `n`, which must be 0..19: 0, or a negative
+ * errno. Lower-only, even as root: `n` outside 0..19 is -22 (EINVAL), and `n`
+ * below the current value is -13 (EACCES), both with no system call. Children
+ * started afterwards inherit it. Throws under Node.
  */
 declare function setNice(n: i32): i32;
 /**
@@ -492,6 +526,9 @@ declare var crypto: {
 //
 // `docs/LANGUAGE.md` -> Builtins -> Builtin modules is the normative list.
 
+// Every negative errno a file call answers is the platform's own, untranslated:
+// the numbers shown here are Linux's (-2 ENOENT, -17 EEXIST, -18 EXDEV, -22
+// EINVAL, -40 ELOOP), and Darwin's differ (ELOOP is -62 there).
 declare module "nish:fs" {
   export function readFileSync(path: string): string;
   export function readFileSyncOrNull(path: string): string | null;
@@ -506,6 +543,12 @@ declare module "nish:fs" {
   export function renameSync(from: string, to: string): i32;
   /** 0, or a negative errno: a directory is refused, not removed. */
   export function unlinkSync(path: string): i32;
+  /** The byte count, or a negative errno; the file is exactly `mode` (0..0o777) before it holds a byte, a link refused, written in place. */
+  export function writeFileSyncMode(path: string, data: string, mode: i32): i32;
+  /** As `writeFileSyncMode`, but -17 when anything is at `path`: one racer wins; a failed write removes the file. */
+  export function createFileExclusiveSync(path: string, data: string, mode: i32): i32;
+  /** 0, or a negative errno: -17 for a path already there, whose mode is left alone. */
+  export function mkdirSyncMode(path: string, mode: i32): i32;
   /** `true` when the directory was created, `false` when it already existed. */
   export function mkdirSync(path: string): boolean;
   export function isDirectorySync(path: string): boolean;
@@ -530,6 +573,11 @@ declare module "nish:process" {
    * at either path is refused, and the answer is -1.
    */
   export function spawnSyncTo(argv: string[], stdoutPath: string, stderrPath: string): number;
+  /**
+   * The same run with `stdin` written to the child and its stdout and stderr
+   * appended to the two arrays: the status, or -2 past 16 MiB on a stream.
+   */
+  export function spawnPiped(argv: string[], stdin: readonly u8[], stdout: u8[], stderr: u8[]): i32;
   /** Start a child without waiting: its pid, or a negative errno. */
   export function spawn(argv: string[]): i32;
   /** Send 0, 2, 9 or 15 to `pid`: 0, or a negative errno; any other signal is -22. */
@@ -540,7 +588,7 @@ declare module "nish:process" {
   export function availableParallelism(): i32;
   /** Bytes of physical memory, or -1. */
   export function totalMemory(): i64;
-  /** Set this process's nice value (clamped to -20..19): 0, or a negative errno. */
+  /** Set this process's nice value, 0..19 only: 0, -22 outside it, or -13 below the current value (lower-only, even as root). */
   export function setNice(n: i32): i32;
   /**
    * Move this process to `SCHED_IDLE`: 0, a negative errno, or -95 off Linux.

package/runtime/nish.h

@@ -282,6 +282,20 @@ nish_array *nish_alloc_array(uint64_t elem_size, uint64_t len);
    Variable-time: never call it on a secret. */
 int64_t nish_regex_scan(const nish_str *s, const nish_array *masks, int64_t depth, int64_t off, int64_t width,
                         int64_t from);
+/* `Math.floor`, `Math.ceil` and `Math.trunc`, and the floor `Math.round`
+   takes (#943): each answers as C's `floor`, `ceil` and `trunc` do, -0, the
+   infinities and NaN included. A module for x86-64 calls them and registers a
+   constructor in `@llvm.global_ctors` that passes `nish_round_init` libm's
+   `floor`, `ceil` and `trunc`; it asks the CPU for SSE4.1 once before `main`
+   and keeps them on a machine without it, or under `NISH_SIMD=scalar`. Each
+   is otherwise SSE4.1's `roundsd`, so the constructor must run first. The
+   runtime references no libm symbol: the module that rounds does. They live
+   in runtime/runtime-simd.c; runtime-wasm.c has the wasm32 ones for host IR
+   that `scripts/build.sh --profile wasm` links. */
+void nish_round_init(double (*floor_fn)(double), double (*ceil_fn)(double), double (*trunc_fn)(double));
+double nish_floor(double x);
+double nish_ceil(double x);
+double nish_trunc(double x);
 /* No array grows past 2^31 - 1 elements and no string past 2^31 - 1 bytes:
  * `nish_array_grow`, `nish_alloc_array` and `nish_str_concat` fail as an
  * allocation does (`nish: out of memory`, exit 1; a trap on wasm) rather than
@@ -403,10 +417,24 @@ nish_array *nish_read_file_bytes(const nish_str *path);
  * errno — -EXDEV for a rename across file systems, which moves nothing, and
  * -EISDIR or -EPERM for a directory handed to `nish_unlink`, which never calls
  * rmdir. A path holding a NUL answers -EINVAL, not -ENOENT, so a program can
- * tell a malformed path from a missing file. */
+ * tell a malformed path from a missing file. The numbers are the platform's
+ * errno values, untranslated: -ELOOP is -40 on Linux and -62 on Darwin. */
 int32_t nish_rename(const nish_str *from, const nish_str *to);
 int32_t nish_unlink(const nish_str *path);
 int32_t nish_write_file_bytes(const nish_str *path, const nish_array *bytes);
+/* `writeFileSyncMode(path, data, mode)`, `createFileExclusiveSync(path, data,
+ * mode)` and `mkdirSyncMode(path, mode)`: a file written, or created only if
+ * nothing is at the path (`O_EXCL`), then `fchmod`ed to exactly `mode` before a
+ * byte is written; a directory made with `mode & ~umask`. A link at a file's
+ * path is refused. The file writers answer the byte count and `nish_mkdir_mode`
+ * 0, or a negative platform errno: -EEXIST for an exclusive create or a mkdir
+ * that finds the path taken (a directory's mode is then left alone), -EINVAL
+ * for a mode outside 0..0777 (the setuid, setgid and sticky bits included) or
+ * a path holding a NUL, -ENOSYS under WASI. A failed exclusive create leaves
+ * no file behind. */
+int32_t nish_write_file_mode(const nish_str *path, const nish_str *data, int32_t mode);
+int32_t nish_create_file_exclusive(const nish_str *path, const nish_str *data, int32_t mode);
+int32_t nish_mkdir_mode(const nish_str *path, int32_t mode);
 /* `writeBytes(bytes, off, len)` (nish:io), in runtime-os.c: the bytes
  * `[off, off + len)` of a `u8[]` on stdout, a short write finished and `EINTR`
  * retried. The caller has range-checked `off` and `len`. Answers `len`, or the
@@ -438,6 +466,17 @@ int32_t nish_spawn_to(const nish_array *argv, const nish_str *out, const nish_st
  * own error otherwise, and -ENOSYS under WASI. The child is reaped by
  * `nish_wait_pid`. */
 int32_t nish_spawn_child(const nish_array *argv);
+/* `spawnPiped(argv, stdin, stdout, stderr)`: start element 0 of `argv` as
+ * `nish_spawn` does, with the bytes of `stdin` (a `u8[]`) on its standard input
+ * and its standard output and error appended to `stdout` and `stderr`, wait for
+ * it, and answer `nish_spawn`'s status. -1 is `nish_spawn`'s -1, a pipe or
+ * `poll` that fails included, and always under WASI. -2 is a stream that passed
+ * 16 MiB: the child is killed with SIGKILL and reaped, and that array holds the
+ * stream's first 16 MiB. The two output arrays grow as `push` grows them, so
+ * the compiler treats both as pushed. `stdin` is read in place and never
+ * copied; SIGPIPE is blocked on the calling thread for the call, a SIGPIPE the
+ * call raised is consumed, and the thread's mask is restored after it. */
+int32_t nish_spawn_piped(const nish_array *argv, const nish_array *in, nish_array *out, nish_array *err);
 /* `kill(pid, sig)`: send `sig` to `pid` and answer 0, or a negative errno. Only
  * 0, 2 (SIGINT), 9 (SIGKILL) and 15 (SIGTERM) are sent; any other signal, and
  * a pid of 0 or below, is -EINVAL. -ESRCH when no process has the pid, -EPERM
@@ -455,9 +494,9 @@ nish_array *nish_wait_pid(int32_t pid, int32_t flags);
  * page size; Darwin: `hw.memsize`), or -1 where the host does not say. */
 int64_t nish_total_memory(void);
 /* `setNice(n)`: this process's nice value set to `n` (`setpriority`), 0 or a
- * negative errno. The kernel clamps `n` to -20..19; lowering it below the
- * current value without the privilege is -EACCES (or -EPERM). -ENOSYS under
- * WASI. */
+ * negative errno. Lower-only, as root too: `n` takes 0..19, and anything else
+ * is -22 (-EINVAL) with no system call; `n` below the current value is -13
+ * (-EACCES) with none either. -ENOSYS under WASI. */
 int32_t nish_set_nice(int32_t n);
 /* `setIdlePriority()`: this process moved to `SCHED_IDLE` (Linux), 0 or a
  * negative errno; -95 (Linux's EOPNOTSUPP) elsewhere, -ENOSYS under WASI. An

package/runtime/nish.mjs

@@ -94,12 +94,16 @@ provide("appendFileSync", shim.appendFileSync);
 provide("writeFileBytesSync", shim.writeFileBytesSync);
 provide("renameSync", shim.renameSync);
 provide("unlinkSync", shim.unlinkSync);
+provide("writeFileSyncMode", shim.writeFileSyncMode);
+provide("createFileExclusiveSync", shim.createFileExclusiveSync);
+provide("mkdirSyncMode", shim.mkdirSyncMode);
 provide("mkdirSync", shim.mkdirSync);
 provide("isDirectorySync", shim.isDirectorySync);
 provide("readdirSync", shim.readdirSync);
 provide("realpathSync", shim.realpathSync);
 provide("spawnSync", shim.spawnSync);
 provide("spawnSyncTo", shim.spawnSyncTo);
+provide("spawnPiped", shim.spawnPiped);
 // WP34 N12. `spawn` and `waitPid` throw, naming themselves: a child is reaped
 // by Node's event loop. `kill`, `availableParallelism` and `totalMemory` answer.
 provide("spawn", shim.spawn);

package/runtime/node.mjs

@@ -102,6 +102,46 @@ const unlinkSync = (path) => errnoOr(0, () => fs.unlinkSync(path));
 const writeFileBytesSync = (path, bytes) =>
   errnoOr(bytes.length, () => fs.writeFileSync(path, Uint8Array.from(bytes), { flag: WRITE_FLAGS, mode: 0o644 }));
 
+/**
+ * `writeFileSyncMode` and `createFileExclusiveSync`'s shared body, as
+ * `runtime-os.c`'s: the file opened with `flag`, `fchmod`ed to exactly `mode`
+ * before a byte is written, then every byte of `data`, then the count, or a
+ * negative errno. A mode outside 0..0o777 is -22 before the file is touched.
+ * After an exclusive create (`"wx"`), any failure unlinks the file it made.
+ */
+function putFileMode(path, data, flag, mode) {
+  if (!(mode >= 0 && mode <= 0o777)) return -22;
+  let fd;
+  try {
+    fd = fs.openSync(path, flag, mode);
+  } catch (e) {
+    return negErrno(e);
+  }
+  let r;
+  try {
+    fs.fchmodSync(fd, mode);
+    const buf = Buffer.from(data, "utf8");
+    for (let done = 0; done < buf.length; ) done += fs.writeSync(fd, buf, done);
+    r = buf.length;
+  } catch (e) {
+    r = negErrno(e);
+  }
+  const closed = errnoOr(0, () => fs.closeSync(fd));
+  const answer = r >= 0 && closed < 0 ? closed : r;
+  if (answer < 0 && flag === "wx") errnoOr(0, () => fs.unlinkSync(path));
+  return answer;
+}
+
+/** `writeFileSyncMode(path, data, mode)`: `WRITE_FLAGS`, so a link at the path is refused. */
+const writeFileSyncMode = (path, data, mode) => putFileMode(path, data, WRITE_FLAGS, mode);
+
+/** `createFileExclusiveSync(path, data, mode)`: `"wx"`, -17 when anything is at the path. */
+const createFileExclusiveSync = (path, data, mode) => putFileMode(path, data, "wx", mode);
+
+/** `mkdirSyncMode(path, mode)`: 0, or a negative errno; -17 for a path already there. */
+const mkdirSyncMode = (path, mode) =>
+  mode >= 0 && mode <= 0o777 ? errnoOr(0, () => fs.mkdirSync(path, { mode })) : -22;
+
 /**
  * `writeBytes`'s write, after the core checked the range `[from, to)`: every
  * byte to stdout, then the count, or a negative errno. `fs.writeSync` may
@@ -268,6 +308,41 @@ function spawnSyncTo(argv, out, err) {
   return spawnImpl(argv, out, err);
 }
 
+/** The bytes `spawnPiped` keeps of one stream, as `runtime-os.c`'s `NISH_PIPED_CAP`. */
+const PIPED_CAP = 16 * 1024 * 1024;
+
+/**
+ * `spawnPiped(argv, stdin)`'s run, after the core took it apart: the status
+ * and the two streams' bytes, which the core appends to the caller's arrays.
+ * The status is `spawnImpl`'s, and -2 when a stream passed `PIPED_CAP`: Node
+ * then kills the child with `SIGKILL`, as the runtime does, and reports
+ * `ENOBUFS`, and what it read is cut to the cap here as the runtime keeps it.
+ * A child that exits without reading its stdin is not an error on either side.
+ */
+function spawnPiped(argv, input) {
+  if (argv.length === 0) return [-1, [], []];
+  let r;
+  // Node throws, rather than reporting, for an empty command or a NUL in any
+  // argument, which the runtime answers -1 for without starting a child.
+  try {
+    r = child_process.spawnSync(argv[0], argv.slice(1), {
+      input: Uint8Array.from(input),
+      maxBuffer: PIPED_CAP,
+      killSignal: "SIGKILL",
+    });
+  } catch {
+    return [-1, [], []];
+  }
+  const bytes = (b) => (b === null || b === undefined ? [] : Array.from(b.subarray(0, PIPED_CAP)));
+  const out = bytes(r.stdout);
+  const err = bytes(r.stderr);
+  // `EPIPE` is the child closing its stdin unread, which Node reports with
+  // the status it still waited for; the runtime ignores it the same way.
+  if (r.error !== undefined && r.error.code !== "EPIPE") return [r.error.code === "ENOBUFS" ? -2 : -1, out, err];
+  if (r.signal !== null && r.signal !== undefined) return [128 + (os.constants.signals[r.signal] ?? 0), out, err];
+  return [r.status === null ? -1 : r.status, out, err];
+}
+
 /**
  * `kill(pid, sig)`: 0, or a negative errno, as `runtime-os.c`'s `nish_kill`
  * answers. Only 0, 2, 9 and 15 are sent and a pid of 0 or below is refused,
@@ -393,6 +468,9 @@ const CALLS = {
   writeFileBytesSync,
   renameSync,
   unlinkSync,
+  writeFileSyncMode,
+  createFileExclusiveSync,
+  mkdirSyncMode,
   writeBytes,
   mkdirSync,
   isDirectorySync,
@@ -403,6 +481,7 @@ const CALLS = {
   getenv,
   spawnSync,
   spawnSyncTo,
+  spawnPiped,
   kill,
   availableParallelism,
   totalMemory,