@amritk/nish-x86_64-linux 0.27.2 → 0.29.0

package/INSTALL.md

@@ -254,7 +254,9 @@ routes are
   # on the musl host, with its own clang and the runtime from this repository
   clang app.ll runtime/runtime.c runtime/runtime-os.c runtime/runtime-parallel.c \
     runtime/runtime-cross.c runtime/runtime-host.c runtime/runtime-net.c \
-    runtime/runtime-simd.c runtime/runtime-aes.c runtime/runtime-term.c runtime/runtime-bytes.c -lm -o app
+    runtime/runtime-simd.c runtime/runtime-aes.c runtime/runtime-sha256.c runtime/runtime-term.c \
+    runtime/runtime-bytes.c runtime/runtime-checksum.c runtime/runtime-sandbox.c \
+    runtime/runtime-shm.c -lm -o app
   ```
 
   `--link`ing inside the container is the mistake to avoid: it shells out to the
@@ -390,7 +392,7 @@ it into `build/seed/`; `NISH_BOOTSTRAP=<path>` names one you already have and
 skips the download. §2a has what the build does with it.
 
 The published package ships `bin/` (the `nish` command, which is a launcher),
-`runtime/` (the C runtime — ten translation units, the wasm subset and their
+`runtime/` (the C runtime — fourteen translation units, the wasm subset and their
 header — and `runtime/sqlite/`, SQLite's vendored source),
 `scripts/build.sh` (the link pipeline), `std/` (the standard library) and
 `docs/AI.md` (the rules card). The
@@ -403,12 +405,14 @@ working directory — and the binary runs from inside its own platform package
 for exactly that reason.
 
 Building the IR yourself rather than through `--link` means naming the runtime
-on the `clang` line, and it is ten files:
+on the `clang` line, and it is fourteen files:
 
 ```bash
 clang app.ll runtime/runtime.c runtime/runtime-os.c runtime/runtime-parallel.c \
   runtime/runtime-cross.c runtime/runtime-host.c runtime/runtime-net.c \
-  runtime/runtime-simd.c runtime/runtime-aes.c runtime/runtime-term.c runtime/runtime-bytes.c -lm -o app
+  runtime/runtime-simd.c runtime/runtime-aes.c runtime/runtime-sha256.c runtime/runtime-term.c \
+  runtime/runtime-bytes.c runtime/runtime-checksum.c runtime/runtime-sandbox.c \
+  runtime/runtime-shm.c -lm -o app
 ```
 
 `runtime.c` is the part every program touches — the arena, strings, arrays,
@@ -421,14 +425,18 @@ the strings and arrays a task answers, a channel sends or a `Mutex` keeps out
 of the arena they were made in, `runtime-host.c` holds the wall clock,
 entropy, file times and signals, `runtime-net.c` the sockets of `nish:net`,
 `runtime-simd.c` and `runtime-aes.c` the vector text search and AES-GCM,
-`runtime-term.c` the stdin reads and terminal calls of `nish:term`, and
+`runtime-sha256.c` the SHA-256 block kernel `nish/crypto/sha256` hands its
+blocks to on a CPU with the SHA instructions (`NISH_SHA256=soft` keeps the
+portable path), `runtime-term.c` the stdin reads and terminal calls of `nish:term`,
 `runtime-bytes.c` the byte-class runs of `nish/bytes`, which `nish/json` steps
-over.
+over, `runtime-checksum.c` the CRC-32 kernels of `nish/compress/checksum`,
+`runtime-sandbox.c` the confinement a `--sandbox` build applies, and
+`runtime-shm.c` the shared-memory regions of `nish/sync/shm`.
 They are separate so that each carries its own measured size ceiling
 ([docs/wp7-runtime.md](wp7-runtime.md)); nothing in the core calls into the
 others, so a line that names only `runtime.c` and `runtime-os.c` still links a
-program that uses none of the other eight. `scripts/build.sh` compiles the other
-eight beside any
+program that uses none of the other nine. `scripts/build.sh` compiles the other
+nine beside any
 `runtime.c` it is handed, so a build that goes through it — every `--link`,
 and every `--profile` recipe in these documents — needs to name only the one.
 

package/docs/AI.md

@@ -180,7 +180,7 @@ rejects. This table is the highest-value part of the page.
 | `keyof T`, `<T = i32>` (a default type argument) | `` Unsupported type `keyof T` (Phase 1 supports …) `` / `a default type argument … is not supported` | name the type; a type argument is always inferred |
 | `class B extends A` | `` `extends` is not supported: Nish has no inheritance `` | repeat the fields and `implements` an interface |
 | `static` members, `get x()` / `set x(v)` | `` … `static` members are not supported `` / `` Getters and setters are not supported in class `C` (use a method) `` | module `const`s and plain methods |
-| `const [a, b] = xs`, `({ x }: Point) =>`, `(n = 1)`, `(n?: i32)`, `(...ns: i32[])` | `Destructuring is not supported` / `Destructured parameters are not supported` / `Optional/default parameters are not supported` / `Rest parameters are not supported` | one name per binding, every parameter passed; an array for a variable count |
+| `const [a, b] = xs`, `({ x }: Point) =>`, `(n?: i32)`, `(n = 1)`, `f(...xs)` | `Destructuring is not supported` / `Destructured parameters are not supported` / `Optional parameters are not supported` / `` Parameter `n` has a default and no type annotation `` / `Spread arguments are not supported` | one name per binding; `n: i32 = 1` (a constant or an earlier parameter) for a default; `...ns: i32[]` as the last parameter, or pass the array itself |
 | `function f(): void;` (an overload), `export default function ()` | `Functions must have a body` / `Functions must be named` | one named function, with its body |
 | a method in an `interface` | `` Interface `I` cannot declare methods (interfaces describe layout only) `` | fields only; a top-level function over the interface |
 | `abstract class`, `declare class`, `constructor(public x: i32)`, `interface B extends A`, `[k: string]: T` | `Abstract classes are not supported` / `` `declare class` is not supported `` / `Parameter properties … are not supported; declare the field and assign it` / ``Interface inheritance (`extends`) is not supported; list every field`` / `Index signatures are not supported …` | a plain class with its fields declared and assigned in the constructor; every field listed; a `Map` for a keyed table |
@@ -845,10 +845,14 @@ export const main = (): i32 => {
 - **Call it, or pass it on to another function parameter. Nothing else**:
   `const g = f`, `return f` and `[f]` are
   `` `f` is a function parameter and can only be called or passed on as a function argument ``.
-- **An arrow captures nothing.** It sees its own parameters and top-level
-  names; reading a local of the function around it is
-  `` The arrow reads `k`, which belongs to the function it is written in ``.
-  Pass the value in as another argument of the template instead.
+- **An arrow may read the `const` locals and parameters of the function it is
+  written in**, and write through a captured reference
+  (`(x) => { if (x > limit) { hits.push(x) } }`); each capture becomes one more
+  argument of the direct call. It may not assign to one, read a `let`
+  (`` The arrow reads `k`, a `let` of the function it is written in: ... bind the value to a `const` before the call ``),
+  read `this` (bind `const self = this`), or read a function parameter of its
+  function. An arrow inside another arrow, or given to a method, a
+  constructor, `expose` or `exposeWith`, captures nothing.
 - **The argument's type must match exactly**: `(x: i32) => i64` for a
   `(x: i32) => i32` parameter is refused. A generic function cannot be passed
   by name — write `(x) => identity(x)`.
@@ -858,12 +862,13 @@ export const main = (): i32 => {
 - **Only a top-level function** may have one: not a method, a constructor, a
   field, a local, a return type or an alias.
 
-```ts nish:err NL2335
+```ts nish:err NL2585
 const apply = (f: (x: i32) => i32, x: i32): i32 => f(x);
 
 export const main = (): i32 => {
-  const k = 3;
-  return apply((x) => x + k, 1);   // captures `k`: pass it to `apply` instead
+  let k = 3;
+  k = k + 1;
+  return apply((x) => x + k, 1);   // reads the `let` `k`: bind `const kNow = k` before the call
 };
 ```
 
@@ -976,6 +981,11 @@ export const main = (): i32 => {
   (NL2388): `using s = scope()`.
   The scope is only ever the receiver of a `spawn` statement: never pass it,
   store it or return it.
+- **A task that recurses deeply gets a bigger stack from `scopeWithStack`.**
+  `using s = scopeWithStack(64 * 1024 * 1024)` is a scope whose tasks each run
+  on a new thread with a 64 MiB stack; a thread's default is 8 MiB. Ask for at
+  least 131072 bytes: a number below it is refused (NL2584). Under Node the size
+  is ignored, so run Node with `--stack-size` too.
 - **The task is a top-level function named in the `spawn`, or an arrow written
   there.** `s.spawn(entry, arg)` with no destination runs an entry that
   answers `void`; `s.spawn(() => work(a, b))` runs an arrow that reads the
@@ -1893,32 +1903,52 @@ export const main = (): i32 => {
   `push` inside the body extends the loop. `for...in`, `for await` and
   `for (x of xs)` over an existing `x` are each refused by name.
 - `switch` takes an **integer or enum** discriminant; every `case` label is an
-  integer constant expression of that type. **There is no implicit
-  fallthrough** — a clause with statements ends in `break`, `return`,
-  `continue` or `process.exit`, unless it is the last. An *empty* clause does
-  fall through, which is how `case 1: case 2:` shares a body. A clause cannot
-  declare a variable directly; wrap its body in a block.
-- `break` / `continue` are unlabelled only; labeled statements are forbidden.
+  integer constant expression of that type. A clause that does not end in
+  `break`, `return`, `continue` or `process.exit` **falls through** into the
+  next, as in TypeScript; an *empty* clause is how `case 1: case 2:` shares a
+  body. A clause reached by falling into it is not narrowed by its label. A
+  clause cannot declare a variable directly; wrap its body in a block.
+- **Labels** go on a loop, a block or a `switch`: `break outer` leaves the
+  statement named `outer` from any depth, `continue outer` starts the next
+  turn of the loop named `outer`. A label on any other statement is refused,
+  and a jump cannot leave an arrow for a label outside it.
 - `process.exit(code)` and `panic(msg)` **terminate control flow**, so a
   non-`void` function may end with either.
 - **Unreachable code is an error**, not a warning: anything after a `return`,
   `break`, `continue`, `process.exit`, an `if` whose branches all return, or an
   infinite loop.
 
-```ts nish:err NL2166
-const classify = (n: i32): string => {
+```ts nish:ok
+const firstPair = (limit: i32, target: i32): i32 => {
+  outer: for (let i: i32 = 0; i < limit; i++) {
+    for (let j: i32 = 0; j < limit; j++) {
+      if (i * j === target) {
+        return i * 100 + j;
+      }
+      if (j > i) {
+        continue outer;   // the next `i`
+      }
+    }
+  }
+  return -1;
+};
+
+const classify = (n: i32): i32 => {
+  let score: i32 = 0;
   switch (n) {
     case 0:
-      console.log("zero");   // no `break`: a clause with statements must end in one
+      score += 10;   // no `break`: falls into `case 1`
     case 1:
-      return "one";
+      score += 1;
+      break;
     default:
-      return "many";
+      score = -1;
   }
+  return score;
 };
 
 export const main = (): i32 => {
-  console.log(classify(0));
+  console.log(`${firstPair(10, 12)} ${classify(0)} ${classify(1)}`);   // 304 11 1
   return 0;
 };
 ```
@@ -2181,6 +2211,10 @@ 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.
+`spawnWithFds(argv, fds)` is `spawn` that hands the child `fds[i]` as
+descriptor `3 + i` (systemd's `LISTEN_FDS` numbering); every other descriptor
+still closes at exec. More than 64, or a negative one, is `-22`; it needs
+`process.spawn` under `--sandbox`, refuses a wasm target and throws under Node.
 `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`
@@ -2230,8 +2264,42 @@ unread is reported again. Add `signalFd()` to the loop to wake on SIGTERM.
 `NET_SO_KEEPALIVE`, `NET_SO_SNDBUF` and `NET_SO_RCVBUF`, `i32` ids exported
 beside it; any other id is `-22`. Linux drops quick-ACK mode on its own, so set
 it again after each response. The ids are not module constants: pass them
-directly. None
-exists on a wasm target, and under Node each throws.
+directly. `netMss(fd)` answers a connected TCP socket's send MSS, the payload
+bytes one segment carries, and `-1` for anything else (never an errno), so size
+writes by it with a fallback. None but `netMss` exists on a wasm target (there
+it is always `-1`), and under Node each throws.
+
+Unix-domain stream sockets: `unixListen(path, backlog, flags)` listens on a
+socket file left at 0600 (`unixListenMode(path, backlog, flags, mode)` for
+another mode), `unixConnect(path)` and `unixAccept(fd)` answer descriptors
+that `netRead`, `netWrite`, `netShutdown`, `netClose` and the loop take as
+they are, and `unixSocketPair(NET_UNIX_STREAM, fds)` fills `fds: i32[]` with
+two connected ends (`NET_UNIX_SEQPACKET` keeps message boundaries; Linux
+only, `-95` on Darwin). A path starting with `@` is Linux's abstract
+namespace and makes no file (`-95` on Darwin); write `./@name` for a socket
+file so named. A path that exists is `-98`; flag `NET_UNIX_UNLINK_STALE`
+first removes a socket file nobody listens on (Linux; on Darwin it is `-95`
+at a socket file, since a full backlog and a dead file both refuse there).
+`NET_UNIX_UNLINK_STALE`, `NET_UNIX_STREAM` and `NET_TCP_NODELAY` are all `1`,
+so pass the constant each call names. A path as written is at most 107
+bytes (103 on Darwin) and an abstract name at most 107 after its `@`; longer
+is `-36`. A full backlog makes `unixConnect`
+`-11` on Linux and `-111` on Darwin. Under `--sandbox`, a listener on a path
+also needs `fs.write` (`-13` without it); an abstract name does not, and a
+connect to a path is not confined. `sendFd(sock, fd, buf, off, len)` sends
+`buf[off, off + len)` with descriptor `fd` attached (`len` 0 is `-22`) and
+answers the bytes sent, which on a stream socket can be short: the descriptor
+went with the first bytes, so send the rest with `netWrite`; `recvFd(sock, buf, off, len, fd)` reads into the
+range and sets `fd[0]` to the descriptor that came with it, or `-1`; the
+descriptor arrives close-on-exec, its status flags (`O_NONBLOCK` among them)
+the open file's, which the sender shares, any beyond the first are closed,
+and `fd` shorter than 1 is `-22`. `peerCredentials(sock, out)` writes
+`[pid, uid, gid]` of the process that made the connection, as it was at
+connect time, into an `out` of length 3 or more (`-22` shorter, `-107` for a
+listener or a socket never connected); on Darwin the
+pid can be `-1`. All three answer `-88` or `-95` for a socket that is not
+Unix-domain. The Unix calls are refused on a wasm target, and under Node each
+throws.
 
 **Arena.** `Arena.mark()`, `Arena.used()` and `using a = arena()` — see below.
 `Arena.release(m)` and `Arena.reset()` were removed before 1.0: write
@@ -2261,6 +2329,10 @@ console.log(`${seen.size} ${counts.size} ${seen.has("b")}`);
 - A key is a string, any number type, a `boolean`, an enum or a class instance
   (by identity). An interface, an array, a nullable type or a `Result` is not a
   key; a value is anything but `void` or an interface.
+- A pair of `i32`s is one `i64` key, not a string: `(toI64(a) << toI64(32)) |
+  toI64(toU32(b))`. Every operand is an `i64` so it also runs
+  under Node, where `i64` is a `BigInt`; it is exact for every pair. A `+` in
+  place of `|` overflows at `a = -2^31` with a negative `b`.
 - A module that declares its own `Map` or `Set` keeps it, but then no other
   module of the program may name the global one.
 
@@ -2619,7 +2691,8 @@ negative `DEFLATE_ERR_*` / `GZIP_ERR_*` code for any malformed stream, so test
 it before reading `out`. `GzipWriter` and `GzipReader` stream. On HTTP/1.1,
 `conn.respondEncoded(status, names, values, body, off, len, enc,
 conn.acceptEncoding())` with an `HttpCompressor` from `nish/net/http-compress`
-negotiates, compresses and sets the fields. Do not compress a secret beside
+negotiates, compresses when it pays (`minLength`, `minSavingPercent`,
+`segmentMode`; `enc.decision` says why not) and sets the fields. Do not compress a secret beside
 text the client chose (BREACH). (No block, as for `nish/text`;
 `tests/link/std_compress` is its program, and the user guide's
 [compression page](guide/using-nish/compression.md) its walk-through.)
@@ -2665,7 +2738,7 @@ or `PG_LOST` to `fail(run)` (on a spent handle these do nothing and count in
 `stray`), and after each call `next(run)` until
 `PG_BATCH_NONE`: `PG_BATCH_ROW` (the connection's row answers request `tag`),
 then one of `PG_BATCH_DONE`, `PG_BATCH_MISSING` or `PG_BATCH_FAILED` per
-request. It reads no clock: when to take is the loop's choice. (No block;
+request. It reads no clock: when to take is the loop's choice, or a `PgBatchClock`'s (`PgBatchClockConfig`: `minCount`, `factor` × the moving average of batch sizes, `maxWaitUs`, the idle bypass `lightCount`; defaults are a fixed window), which `takeDue(conn, clock, nowUs, pool.inFlight())` consults after `clock.arrived(nowUs)` per add; `PgBatchTurns` wakes one collecting connection only when its batch is due. (No block;
 `tests/postgres/live`'s `batch` scenario runs it against a server, and the user
 guide's [PostgreSQL page](guide/using-nish/postgres.md#batching-keyed-reads)
 its walk-through.)
@@ -2709,8 +2782,11 @@ export const main = (): i32 => {
 };
 ```
 
-**Optional parameters** — there are none. Write two functions with different
-names, or take the value and document the sentinel.
+**Optional parameters** — write a default instead: `(n: i32 = 1)`. A default
+is a literal, an enum member or an earlier parameter, and the call site fills
+it in. `x?: T` is refused. A variable count of one type is a rest parameter,
+`(...ns: i32[])`, last in the list; a call never spreads (`f(...xs)`), it passes
+`xs` to an array parameter.
 
 **A calendar, regex, JSON, threads of your own** — not in the language (the
 wall clock is `Date.now()`, and that is all of `Date`). Say so rather than
@@ -2822,6 +2898,22 @@ const settings = (): string => readFileSync("settings.txt");
 export const main = (): i32 => settings().length;
 ```
 
+The policy judges the source; `--sandbox` (Linux, `--link` and `nish run`)
+makes the kernel hold the running binary to the same set. Before any C
+constructor runs, it withholds every file, process and socket operation `main`
+does not reach, C code it links included. A file operation it refuses fails
+like a missing permission; a refused process or socket call ends the program
+with `SIGSYS` (status 159); a kernel that cannot apply it exits 126 before
+`main` unless built with `--sandbox=best-effort`. A darwin target, a library
+with no `main` and `--emit-napi` refuse the flag
+([LANGUAGE.md](LANGUAGE.md#the-sandbox)). Only under `--sandbox` may an
+`--allow` list scope `fs.read` or `fs.write` to a directory
+(`--allow fs.read=/srv/data`): the directory must exist at build time, and
+the kernel grants the capability beneath it alone — except that a `main`
+reaching `process.spawn` can still read every file beneath `/`, so that
+`exec` can load a program. Any other scope, a scope
+in `--deny` and a scope without `--sandbox` are usage errors, exit 2.
+
 ## Before you say it compiles
 
 Run it. `nish file.ts --json` is one command and it is the only proof.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/nish-x86_64-linux",
-  "version": "0.27.2",
+  "version": "0.29.0",
   "description": "The nish native compiler for Linux on x86_64",
   "license": "MIT",
   "os": [

package/runtime/core/host.d.ts

@@ -73,8 +73,9 @@ export declare function isTerminal(fd: i32): boolean;
 export declare function terminalSize(): i32[];
 /** `crypto.getRandomValues(bytes)` for a `u8[]`; a typed array goes straight through. */
 export declare function getRandomValues<T extends u8[] | Uint8Array>(bytes: T): T;
-/** These four have no synchronous reading: each throws, naming itself, and is typed as `runtime/nish.d.ts` types it. */
+/** These five have no synchronous reading: each throws, naming itself, and is typed as `runtime/nish.d.ts` types it. */
 export declare function spawn(argv: string[]): i32;
+export declare function spawnWithFds(argv: string[], fds: readonly i32[]): i32;
 export declare function waitPid(pid: i32, flags: i32): i32[];
 export declare function signalFd(): i32;
 export declare function readSignal(fd: i32): i32;

package/runtime/core/host.mjs

@@ -309,6 +309,10 @@ export function spawn() {
   return noProcessReading("spawn");
 }
 
+export function spawnWithFds() {
+  return noProcessReading("spawnWithFds");
+}
+
 export function waitPid() {
   return noProcessReading("waitPid");
 }

package/runtime/core.d.ts

@@ -7,3 +7,50 @@ export * from "./core/host.js";
 export * from "./core/numbers.js";
 export * from "./core/result.js";
 export * from "./core/strings.js";
+
+// `nish:simd`: what `--emit-ts` writes for a program's `import ... from "nish:simd"`.
+import type { f32, f64, i32, u16, u32, u8 } from "./core/numbers.js";
+
+/**
+ * A sixteen-byte vector of lanes. Opaque: TypeScript refuses `+` on one, as
+ * `nish` does, but lets `===` and `<` through, which `nish` refuses. Under
+ * Node it is a typed array made once and never written after.
+ */
+export interface u8x16 { readonly __nishSimd: "u8x16"; readonly __lane: u8 }
+export interface u16x8 { readonly __nishSimd: "u16x8"; readonly __lane: u16 }
+export interface i32x4 { readonly __nishSimd: "i32x4"; readonly __lane: i32 }
+export interface u32x4 { readonly __nishSimd: "u32x4"; readonly __lane: u32 }
+export interface f32x4 { readonly __nishSimd: "f32x4"; readonly __lane: f32 }
+export interface f64x2 { readonly __nishSimd: "f64x2"; readonly __lane: f64 }
+/** Any of the six. */
+export type SimdVector = u8x16 | u16x8 | i32x4 | u32x4 | f32x4 | f64x2;
+/** One value per lane, lane 0 first. */
+export declare function u8x16(
+  a0: u8, a1: u8, a2: u8, a3: u8, a4: u8, a5: u8, a6: u8, a7: u8,
+  a8: u8, a9: u8, a10: u8, a11: u8, a12: u8, a13: u8, a14: u8, a15: u8
+): u8x16;
+export declare function u16x8(a0: u16, a1: u16, a2: u16, a3: u16, a4: u16, a5: u16, a6: u16, a7: u16): u16x8;
+export declare function i32x4(a0: i32, a1: i32, a2: i32, a3: i32): i32x4;
+export declare function u32x4(a0: u32, a1: u32, a2: u32, a3: u32): u32x4;
+export declare function f32x4(a0: f32, a1: f32, a2: f32, a3: f32): f32x4;
+export declare function f64x2(a0: f64, a1: f64): f64x2;
+/** `x` in every lane. */
+export declare function splatU8x16(x: u8): u8x16;
+export declare function splatU16x8(x: u16): u16x8;
+export declare function splatI32x4(x: i32): i32x4;
+export declare function splatU32x4(x: u32): u32x4;
+export declare function splatF32x4(x: f32): f32x4;
+export declare function splatF64x2(x: f64): f64x2;
+/** `xs[i]` to `xs[i + N - 1]`, bounds-checked once for the whole vector. */
+export declare function loadU8x16(xs: readonly u8[], i: i32): u8x16;
+export declare function loadU16x8(xs: readonly u16[], i: i32): u16x8;
+export declare function loadI32x4(xs: readonly i32[], i: i32): i32x4;
+export declare function loadU32x4(xs: readonly u32[], i: i32): u32x4;
+export declare function loadF32x4(xs: readonly f32[], i: i32): f32x4;
+export declare function loadF64x2(xs: readonly f64[], i: i32): f64x2;
+/** The lanes of `v` into `xs[i]` to `xs[i + N - 1]`, checked once. */
+export declare function store<V extends SimdVector>(v: V, xs: V["__lane"][], i: i32): void;
+/** Lane `k`, an integer literal in range. */
+export declare function extract<V extends SimdVector>(v: V, k: i32): V["__lane"];
+/** A new vector: `v` with lane `k` set to `x`. */
+export declare function replace<V extends SimdVector>(v: V, k: i32, x: V["__lane"]): V;

package/runtime/core.mjs

@@ -48,8 +48,75 @@
  *
  * The rewrite rules that call these helpers are listed in docs/wp13-differential.md.
  */
+import { panicIndex, toIndex } from "./core/checks.mjs";
+
 export * from "./core/arrays.mjs";
 export * from "./core/host.mjs";
 export * from "./core/numbers.mjs";
 export * from "./core/result.mjs";
 export * from "./core/strings.mjs";
+
+// ---- `nish:simd` ------------------------------------------------------------
+// A vector is a fresh typed array of its lanes, made once and never written
+// after: `replace` copies, so a vector held in two places stays one value, as
+// the native `<N x T>` register is. The array type does the lane arithmetic a
+// native lane does: a `u8` lane wraps through `Uint8Array`, an `f32` lane rounds
+// through `Float32Array`. `load…` and `store` check the whole vector once, and
+// panic with the native words: the first index, and the array's length.
+
+const simdMake = (Lanes) => (...lanes) => new Lanes(lanes);
+const simdSplat = (Lanes) => (x) => new Lanes(16 / Lanes.BYTES_PER_ELEMENT).fill(x);
+// The first index of `count` lanes at `i` in `xs`, or the native panic naming
+// a lane that is out of range: the first when it is, else the last. A negative
+// index prints as the unsigned 64-bit number the native compare saw.
+const simdAt = (xs, i, count) => {
+  const k = toIndex(i);
+  if (k < 0) panicIndex(BigInt.asUintN(64, BigInt(k)), xs.length);
+  if (k >= xs.length) panicIndex(k, xs.length);
+  if (k + count > xs.length) panicIndex(k + count - 1, xs.length);
+  return k;
+};
+const simdLoad = (Lanes) => (xs, i) => {
+  const count = 16 / Lanes.BYTES_PER_ELEMENT;
+  const k = simdAt(xs, i, count);
+  const out = new Lanes(count);
+  for (let j = 0; j < count; j++) out[j] = xs[k + j];
+  return out;
+};
+
+export const u8x16 = simdMake(Uint8Array);
+export const u16x8 = simdMake(Uint16Array);
+export const i32x4 = simdMake(Int32Array);
+export const u32x4 = simdMake(Uint32Array);
+export const f32x4 = simdMake(Float32Array);
+export const f64x2 = simdMake(Float64Array);
+export const splatU8x16 = simdSplat(Uint8Array);
+export const splatU16x8 = simdSplat(Uint16Array);
+export const splatI32x4 = simdSplat(Int32Array);
+export const splatU32x4 = simdSplat(Uint32Array);
+export const splatF32x4 = simdSplat(Float32Array);
+export const splatF64x2 = simdSplat(Float64Array);
+export const loadU8x16 = simdLoad(Uint8Array);
+export const loadU16x8 = simdLoad(Uint16Array);
+export const loadI32x4 = simdLoad(Int32Array);
+export const loadU32x4 = simdLoad(Uint32Array);
+export const loadF32x4 = simdLoad(Float32Array);
+export const loadF64x2 = simdLoad(Float64Array);
+
+/** `store(v, xs, i)`: the lanes into `xs[i]` to `xs[i + N - 1]`, checked once. */
+export function store(v, xs, i) {
+  const k = simdAt(xs, i, v.length);
+  for (let j = 0; j < v.length; j++) xs[k + j] = v[j];
+}
+
+/** `extract(v, k)`: lane `k`, a constant the checker held in range. */
+export function extract(v, k) {
+  return v[k];
+}
+
+/** `replace(v, k, x)`: a new vector, `v` with lane `k` set to `x`. */
+export function replace(v, k, x) {
+  const out = v.slice();
+  out[k] = x;
+  return out;
+}