ripgrep 0.0.0 → 0.0.1

package/lib/_wasi.mjs

@@ -0,0 +1,485 @@
+// Minimal WASI preview1 shim implementing only the 20 functions ripgrep imports.
+// Backed by `node:fs` sync APIs, so it works on Node, Bun, and Deno uniformly.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomFillSync } from "node:crypto";
+
+// Errno (subset used here; full table at
+// https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md)
+const E = {
+  SUCCESS: 0,
+  ACCES: 2,
+  BADF: 8,
+  EXIST: 20,
+  INVAL: 28,
+  IO: 29,
+  ISDIR: 31,
+  NAMETOOLONG: 37,
+  NOENT: 44,
+  NOSYS: 52,
+  NOTDIR: 54,
+  NOTSUP: 58,
+};
+
+// Filetype enum
+const FT = {
+  UNKNOWN: 0,
+  BLOCK_DEVICE: 1,
+  CHARACTER_DEVICE: 2,
+  DIRECTORY: 3,
+  REGULAR_FILE: 4,
+  SYMBOLIC_LINK: 7,
+};
+
+const PREOPENTYPE_DIR = 0;
+const OFLAGS_CREAT = 1;
+const OFLAGS_DIRECTORY = 2;
+const OFLAGS_EXCL = 4;
+const OFLAGS_TRUNC = 8;
+const FDFLAGS_APPEND = 1;
+const RIGHTS_FD_READ = 1n << 1n;
+const RIGHTS_FD_WRITE = 1n << 6n;
+
+class WASIExit extends Error {
+  constructor(code) {
+    super(`wasi exit: ${code}`);
+    this.code = code;
+  }
+}
+
+export function createWasi({ args, env, preopens, returnOnExit = true } = {}) {
+  const enc = new TextEncoder();
+  const dec = new TextDecoder();
+
+  const argBytes = args.map((a) => enc.encode(a + "\0"));
+  const envBytes = Object.entries(env)
+    .filter(([, v]) => v != null)
+    .map(([k, v]) => enc.encode(`${k}=${v}\0`));
+
+  // fds: 0/1/2 = stdio, 3+ = preopens, then files/dirs opened at runtime.
+  const fds = [
+    { type: "stdio", which: 0 },
+    { type: "stdio", which: 1 },
+    { type: "stdio", which: 2 },
+  ];
+  for (const [name, hostPath] of Object.entries(preopens)) {
+    fds.push({
+      type: "dir",
+      hostPath: path.resolve(hostPath),
+      preopenName: name,
+    });
+  }
+
+  let memory;
+  const dv = () => new DataView(memory.buffer);
+  const u8 = () => new Uint8Array(memory.buffer);
+
+  const imports = {
+    proc_exit(code) {
+      throw new WASIExit(code);
+    },
+    sched_yield() {
+      return E.SUCCESS;
+    },
+    poll_oneoff(_in, _out, _n, _neventsOut) {
+      // ripgrep doesn't actually need this for file search; stub it.
+      return E.NOTSUP;
+    },
+
+    args_sizes_get(argcPtr, bufSizePtr) {
+      const v = dv();
+      v.setUint32(argcPtr, argBytes.length, true);
+      v.setUint32(
+        bufSizePtr,
+        argBytes.reduce((s, b) => s + b.length, 0),
+        true,
+      );
+      return E.SUCCESS;
+    },
+    args_get(argvPtr, argvBufPtr) {
+      const v = dv();
+      const mem = u8();
+      for (const b of argBytes) {
+        v.setUint32(argvPtr, argvBufPtr, true);
+        argvPtr += 4;
+        mem.set(b, argvBufPtr);
+        argvBufPtr += b.length;
+      }
+      return E.SUCCESS;
+    },
+    environ_sizes_get(countPtr, bufSizePtr) {
+      const v = dv();
+      v.setUint32(countPtr, envBytes.length, true);
+      v.setUint32(
+        bufSizePtr,
+        envBytes.reduce((s, b) => s + b.length, 0),
+        true,
+      );
+      return E.SUCCESS;
+    },
+    environ_get(environPtr, environBufPtr) {
+      const v = dv();
+      const mem = u8();
+      for (const b of envBytes) {
+        v.setUint32(environPtr, environBufPtr, true);
+        environPtr += 4;
+        mem.set(b, environBufPtr);
+        environBufPtr += b.length;
+      }
+      return E.SUCCESS;
+    },
+
+    clock_time_get(id, _precision, timePtr) {
+      let t;
+      if (id === 0) {
+        t = BigInt(Date.now()) * 1_000_000n;
+      } else if (id === 1) {
+        t = process.hrtime.bigint
+          ? process.hrtime.bigint()
+          : BigInt(Math.round(performance.now() * 1e6));
+      } else {
+        return E.INVAL;
+      }
+      dv().setBigUint64(timePtr, t, true);
+      return E.SUCCESS;
+    },
+    random_get(bufPtr, bufLen) {
+      randomFillSync(u8(), bufPtr, bufLen);
+      return E.SUCCESS;
+    },
+
+    fd_read(fd, iovsPtr, iovsLen, nreadPtr) {
+      const e = fds[fd];
+      if (!e) return E.BADF;
+      const v = dv();
+      const mem = u8();
+      try {
+        let total = 0;
+        for (let i = 0; i < iovsLen; i++) {
+          const bufPtr = v.getUint32(iovsPtr + i * 8, true);
+          const bufLen = v.getUint32(iovsPtr + i * 8 + 4, true);
+          let n = 0;
+          if (e.type === "file") {
+            const target = Buffer.from(
+              mem.buffer,
+              mem.byteOffset + bufPtr,
+              bufLen,
+            );
+            n = fs.readSync(e.hostFd, target, 0, bufLen, null);
+            e.pos += BigInt(n);
+          } else if (e.type === "stdio" && e.which === 0) {
+            // No stdin support (would need blocking read). Signal EOF.
+            n = 0;
+          } else {
+            return E.BADF;
+          }
+          total += n;
+          if (n < bufLen) break;
+        }
+        v.setUint32(nreadPtr, total, true);
+        return E.SUCCESS;
+      } catch (err) {
+        return errno(err);
+      }
+    },
+    fd_write(fd, iovsPtr, iovsLen, nwrittenPtr) {
+      const e = fds[fd];
+      if (!e) return E.BADF;
+      const v = dv();
+      const mem = u8();
+      try {
+        let total = 0;
+        for (let i = 0; i < iovsLen; i++) {
+          const bufPtr = v.getUint32(iovsPtr + i * 8, true);
+          const bufLen = v.getUint32(iovsPtr + i * 8 + 4, true);
+          const chunk = mem.subarray(bufPtr, bufPtr + bufLen);
+          if (e.type === "stdio") {
+            if (e.which === 1) process.stdout.write(Buffer.from(chunk));
+            else if (e.which === 2) process.stderr.write(Buffer.from(chunk));
+            else return E.BADF;
+            total += bufLen;
+          } else if (e.type === "file") {
+            const n = fs.writeSync(e.hostFd, chunk, 0, bufLen, null);
+            e.pos += BigInt(n);
+            total += n;
+            if (n < bufLen) break;
+          } else {
+            return E.BADF;
+          }
+        }
+        v.setUint32(nwrittenPtr, total, true);
+        return E.SUCCESS;
+      } catch (err) {
+        return errno(err);
+      }
+    },
+    fd_close(fd) {
+      const e = fds[fd];
+      if (!e) return E.BADF;
+      try {
+        if (e.type === "file") fs.closeSync(e.hostFd);
+        fds[fd] = undefined;
+        return E.SUCCESS;
+      } catch (err) {
+        return errno(err);
+      }
+    },
+    fd_tell(fd, offsetPtr) {
+      const e = fds[fd];
+      if (!e || e.type !== "file") return E.BADF;
+      dv().setBigUint64(offsetPtr, e.pos, true);
+      return E.SUCCESS;
+    },
+    fd_readdir(fd, bufPtr, bufLen, cookie, bufUsedPtr) {
+      const e = fds[fd];
+      if (!e || e.type !== "dir") return E.BADF;
+      const v = dv();
+      const mem = u8();
+      try {
+        if (!e.dirents) {
+          const list = fs.readdirSync(e.hostPath, { withFileTypes: true });
+          e.dirents = list.map((d) => ({
+            name: d.name,
+            nameBytes: enc.encode(d.name),
+            type: direntType(d),
+          }));
+        }
+        let used = 0;
+        const HEAD = 24;
+        for (let i = Number(cookie); i < e.dirents.length; i++) {
+          const d = e.dirents[i];
+          if (bufLen - used < HEAD) {
+            used = bufLen;
+            break;
+          }
+          v.setBigUint64(bufPtr + used + 0, BigInt(i + 1), true); // d_next
+          v.setBigUint64(bufPtr + used + 8, 0n, true); // d_ino
+          v.setUint32(bufPtr + used + 16, d.nameBytes.length, true); // d_namlen
+          v.setUint8(bufPtr + used + 20, d.type); // d_type
+          used += HEAD;
+          const space = Math.min(d.nameBytes.length, bufLen - used);
+          mem.set(d.nameBytes.subarray(0, space), bufPtr + used);
+          used += space;
+          if (space < d.nameBytes.length) {
+            used = bufLen;
+            break;
+          }
+        }
+        v.setUint32(bufUsedPtr, used, true);
+        return E.SUCCESS;
+      } catch (err) {
+        return errno(err);
+      }
+    },
+    fd_filestat_get(fd, filestatPtr) {
+      const e = fds[fd];
+      if (!e) return E.BADF;
+      try {
+        if (e.type === "stdio") {
+          writeFilestat(dv(), filestatPtr, {
+            dev: 0n,
+            ino: 0n,
+            filetype: FT.CHARACTER_DEVICE,
+            nlink: 1n,
+            size: 0n,
+            atim: 0n,
+            mtim: 0n,
+            ctim: 0n,
+          });
+          return E.SUCCESS;
+        }
+        const st =
+          e.type === "file"
+            ? fs.fstatSync(e.hostFd, { bigint: true })
+            : fs.statSync(e.hostPath, { bigint: true });
+        writeFilestat(dv(), filestatPtr, filestatFromNode(st));
+        return E.SUCCESS;
+      } catch (err) {
+        return errno(err);
+      }
+    },
+    fd_fdstat_get(fd, fdstatPtr) {
+      const e = fds[fd];
+      if (!e) return E.BADF;
+      const v = dv();
+      let filetype = FT.UNKNOWN;
+      if (e.type === "stdio") filetype = FT.CHARACTER_DEVICE;
+      else if (e.type === "dir") filetype = FT.DIRECTORY;
+      else if (e.type === "file") filetype = FT.REGULAR_FILE;
+      v.setUint8(fdstatPtr + 0, filetype);
+      v.setUint8(fdstatPtr + 1, 0);
+      v.setUint16(fdstatPtr + 2, 0, true);
+      v.setUint32(fdstatPtr + 4, 0, true);
+      // Grant all rights — ripgrep only reads, so over-granting is harmless.
+      v.setBigUint64(fdstatPtr + 8, ~0n, true);
+      v.setBigUint64(fdstatPtr + 16, ~0n, true);
+      return E.SUCCESS;
+    },
+    fd_prestat_get(fd, prestatPtr) {
+      const e = fds[fd];
+      if (!e || e.type !== "dir" || !e.preopenName) return E.BADF;
+      const v = dv();
+      v.setUint8(prestatPtr + 0, PREOPENTYPE_DIR);
+      v.setUint32(prestatPtr + 4, enc.encode(e.preopenName).length, true);
+      return E.SUCCESS;
+    },
+    fd_prestat_dir_name(fd, pathPtr, pathLen) {
+      const e = fds[fd];
+      if (!e || e.type !== "dir" || !e.preopenName) return E.BADF;
+      const name = enc.encode(e.preopenName);
+      if (name.length > pathLen) return E.NAMETOOLONG;
+      u8().set(name, pathPtr);
+      return E.SUCCESS;
+    },
+
+    path_open(
+      dirfd,
+      _dirflags,
+      pathPtr,
+      pathLen,
+      oflags,
+      fsRightsBase,
+      _fsRightsInheriting,
+      fdflags,
+      openedFdPtr,
+    ) {
+      const e = fds[dirfd];
+      if (!e || e.type !== "dir") return E.BADF;
+      const v = dv();
+      const relPath = dec.decode(u8().subarray(pathPtr, pathPtr + pathLen));
+      const fullPath = path.resolve(e.hostPath, relPath);
+      try {
+        let st;
+        try {
+          st = fs.statSync(fullPath);
+        } catch (err) {
+          // Only swallow ENOENT when O_CREAT is set; propagate everything else.
+          if (!(oflags & OFLAGS_CREAT) || err?.code !== "ENOENT")
+            return errno(err);
+        }
+        if (st?.isDirectory()) {
+          fds.push({ type: "dir", hostPath: fullPath });
+          v.setUint32(openedFdPtr, fds.length - 1, true);
+          return E.SUCCESS;
+        }
+        if (oflags & OFLAGS_DIRECTORY) return E.NOTDIR;
+
+        let flags = 0;
+        const canRead = (BigInt(fsRightsBase) & RIGHTS_FD_READ) !== 0n;
+        const canWrite = (BigInt(fsRightsBase) & RIGHTS_FD_WRITE) !== 0n;
+        if (canRead && canWrite) flags |= fs.constants.O_RDWR;
+        else if (canWrite) flags |= fs.constants.O_WRONLY;
+        else flags |= fs.constants.O_RDONLY;
+        if (oflags & OFLAGS_CREAT) flags |= fs.constants.O_CREAT;
+        if (oflags & OFLAGS_EXCL) flags |= fs.constants.O_EXCL;
+        if (oflags & OFLAGS_TRUNC) flags |= fs.constants.O_TRUNC;
+        if (fdflags & FDFLAGS_APPEND) flags |= fs.constants.O_APPEND;
+
+        const hostFd = fs.openSync(fullPath, flags);
+        fds.push({ type: "file", hostFd, pos: 0n });
+        v.setUint32(openedFdPtr, fds.length - 1, true);
+        return E.SUCCESS;
+      } catch (err) {
+        return errno(err);
+      }
+    },
+    path_filestat_get(dirfd, flags, pathPtr, pathLen, filestatPtr) {
+      const e = fds[dirfd];
+      if (!e || e.type !== "dir") return E.BADF;
+      const relPath = dec.decode(u8().subarray(pathPtr, pathPtr + pathLen));
+      const fullPath = path.resolve(e.hostPath, relPath);
+      try {
+        // bit 0 of lookupflags = symlink_follow
+        const follow = (flags & 1) !== 0;
+        const st = follow
+          ? fs.statSync(fullPath, { bigint: true })
+          : fs.lstatSync(fullPath, { bigint: true });
+        writeFilestat(dv(), filestatPtr, filestatFromNode(st));
+        return E.SUCCESS;
+      } catch (err) {
+        return errno(err);
+      }
+    },
+  };
+
+  return {
+    imports: { wasi_snapshot_preview1: imports },
+    start(instance) {
+      memory = instance.exports.memory;
+      try {
+        instance.exports._start();
+        return 0;
+      } catch (err) {
+        if (err instanceof WASIExit) {
+          if (returnOnExit) return err.code;
+          throw err;
+        }
+        throw err;
+      }
+    },
+  };
+}
+
+// --- internal helpers -------------------------------------------------------
+
+function writeFilestat(v, ptr, s) {
+  v.setBigUint64(ptr + 0, s.dev, true);
+  v.setBigUint64(ptr + 8, s.ino, true);
+  v.setUint8(ptr + 16, s.filetype);
+  v.setBigUint64(ptr + 24, s.nlink, true);
+  v.setBigUint64(ptr + 32, s.size, true);
+  v.setBigUint64(ptr + 40, s.atim, true);
+  v.setBigUint64(ptr + 48, s.mtim, true);
+  v.setBigUint64(ptr + 56, s.ctim, true);
+}
+
+function filestatFromNode(st) {
+  let filetype = FT.UNKNOWN;
+  if (st.isFile()) filetype = FT.REGULAR_FILE;
+  else if (st.isDirectory()) filetype = FT.DIRECTORY;
+  else if (st.isSymbolicLink()) filetype = FT.SYMBOLIC_LINK;
+  else if (st.isBlockDevice()) filetype = FT.BLOCK_DEVICE;
+  else if (st.isCharacterDevice()) filetype = FT.CHARACTER_DEVICE;
+  return {
+    dev: BigInt(st.dev),
+    ino: BigInt(st.ino),
+    filetype,
+    nlink: BigInt(st.nlink),
+    size: BigInt(st.size),
+    atim: BigInt(st.atimeNs ?? 0),
+    mtim: BigInt(st.mtimeNs ?? 0),
+    ctim: BigInt(st.ctimeNs ?? 0),
+  };
+}
+
+function direntType(d) {
+  if (d.isFile()) return FT.REGULAR_FILE;
+  if (d.isDirectory()) return FT.DIRECTORY;
+  if (d.isSymbolicLink()) return FT.SYMBOLIC_LINK;
+  if (d.isBlockDevice()) return FT.BLOCK_DEVICE;
+  if (d.isCharacterDevice()) return FT.CHARACTER_DEVICE;
+  return FT.UNKNOWN;
+}
+
+function errno(err) {
+  switch (err?.code) {
+    case "ENOENT":
+      return E.NOENT;
+    case "EBADF":
+      return E.BADF;
+    case "EACCES":
+    case "EPERM":
+      return E.ACCES;
+    case "EISDIR":
+      return E.ISDIR;
+    case "ENOTDIR":
+      return E.NOTDIR;
+    case "EEXIST":
+      return E.EXIST;
+    case "EINVAL":
+      return E.INVAL;
+    default:
+      return E.IO;
+  }
+}

package/lib/index.d.mts

@@ -0,0 +1,114 @@
+/**
+ * Known ripgrep CLI flags (long + short forms). Used to power
+ * autocomplete for {@link ripgrep} arguments — any string is still
+ * accepted (values, patterns, paths, unknown flags).
+ */
+// prettier-ignore
+export type RgFlag =
+  | "--after-context" | "--auto-hybrid-regex" | "--before-context" | "--binary"
+  | "--block-buffered" | "--byte-offset" | "--case-sensitive" | "--color"
+  | "--colors" | "--column" | "--context" | "--context-separator" | "--count"
+  | "--count-matches" | "--crlf" | "--debug" | "--dfa-size-limit" | "--encoding"
+  | "--engine" | "--field-context-separator" | "--field-match-separator"
+  | "--file" | "--files" | "--files-without-match" | "--fixed-strings"
+  | "--follow" | "--glob" | "--glob-case-insensitive" | "--heading" | "--help"
+  | "--hidden" | "--hostname-bin" | "--hyperlink-format" | "--iglob" | "--ignore"
+  | "--ignore-case" | "--ignore-dot" | "--ignore-exclude" | "--ignore-file"
+  | "--ignore-file-case-insensitive" | "--ignore-files" | "--ignore-global"
+  | "--ignore-parent" | "--ignore-vcs" | "--include-zero" | "--invert-match"
+  | "--json" | "--line-buffered" | "--line-number" | "--line-regexp"
+  | "--max-columns" | "--max-columns-preview" | "--max-count" | "--max-depth"
+  | "--max-filesize" | "--maxdepth" | "--mmap" | "--multiline" | "--multiline-dotall"
+  | "--no-auto-hybrid-regex" | "--no-binary" | "--no-block-buffered" | "--no-byte-offset"
+  | "--no-column" | "--no-context-separator" | "--no-crlf" | "--no-encoding"
+  | "--no-filename" | "--no-fixed-strings" | "--no-follow" | "--no-glob-case-insensitive"
+  | "--no-heading" | "--no-hidden" | "--no-ignore" | "--no-ignore-dot"
+  | "--no-ignore-exclude" | "--no-ignore-file-case-insensitive" | "--no-ignore-files"
+  | "--no-ignore-global" | "--no-ignore-parent" | "--no-ignore-vcs" | "--no-include-zero"
+  | "--no-invert-match" | "--no-line-buffered" | "--no-line-number"
+  | "--no-max-columns-preview" | "--no-messages" | "--no-mmap" | "--no-multiline"
+  | "--no-multiline-dotall" | "--no-one-file-system" | "--no-pcre2" | "--no-pcre2-unicode"
+  | "--no-pre" | "--no-require-git" | "--no-search-zip" | "--no-sort-files" | "--no-text"
+  | "--no-trim" | "--no-unicode" | "--null" | "--null-data" | "--one-file-system"
+  | "--only-matching" | "--passthrough" | "--passthru" | "--path-separator" | "--pcre2"
+  | "--pcre2-unicode" | "--pre" | "--pre-glob" | "--pretty" | "--print0" | "--quiet"
+  | "--regex-size-limit" | "--regexp" | "--replace" | "--require-git" | "--search-zip"
+  | "--smart-case" | "--sort" | "--sort-files" | "--sortr" | "--stop-on-nonmatch"
+  | "--text" | "--threads" | "--trim" | "--type" | "--type-add" | "--type-clear"
+  | "--type-list" | "--type-not" | "--unicode" | "--unrestricted" | "--version"
+  | "--vimgrep" | "--with-filename" | "--word-regexp"
+  | "-A" | "-B" | "-C" | "-E" | "-F" | "-H" | "-I" | "-L" | "-M" | "-N" | "-P"
+  | "-R" | "-S" | "-T" | "-U"
+  | "-a" | "-b" | "-c" | "-d" | "-e" | "-f" | "-g" | "-h" | "-i" | "-j" | "-l"
+  | "-m" | "-n" | "-o" | "-p" | "-q" | "-r" | "-s" | "-t" | "-u" | "-v" | "-w"
+  | "-x" | "-z";
+
+/**
+ * An argument to {@link ripgrep}: a known ripgrep flag (autocompleted)
+ * or any other string (value, pattern, path, `--flag=value`, etc).
+ */
+export type RgArg = RgFlag | (string & {});
+
+/**
+ * Options for {@link ripgrep}.
+ */
+export interface ripgrepOptions {
+  /**
+   * Environment variables passed to the WASI instance.
+   * @default process.env
+   */
+  env?: Record<string, string | undefined>;
+
+  /**
+   * WASI preopened directories, mapping guest paths to host paths.
+   * Required for ripgrep to see any files on disk.
+   * @default { ".": process.cwd() }
+   */
+  preopens?: Record<string, string>;
+
+  /**
+   * When `true`, WASI `proc_exit` returns the exit code from `start()`
+   * instead of terminating the Node process.
+   * @default true
+   */
+  returnOnExit?: boolean;
+
+  /**
+   * Use Node's built-in `node:wasi` module instead of the bundled
+   * custom WASI shim. Also enabled via `ZIGREP_NODE_WASI=1`.
+   * @default false
+   */
+  nodeWasi?: boolean;
+}
+
+/**
+ * Result of a ripgrep invocation.
+ */
+export interface RipgrepResult {
+  /** Exit code: 0 = matches found, 1 = no matches, 2 = error. */
+  code: number;
+}
+
+/**
+ * Run ripgrep (compiled to `wasm32-wasip1`) with the given CLI arguments.
+ *
+ * Returns the ripgrep exit code (0 = matches found, 1 = no matches,
+ * 2 = error), matching the native `rg` binary.
+ *
+ * @example
+ * ```js
+ * import { ripgrep } from "zigrep";
+ * const { code } = await ripgrep(["--json", "TODO", "src"]);
+ * ```
+ */
+export function ripgrep(
+  args?: readonly RgArg[],
+  options?: ripgrepOptions,
+): Promise<RipgrepResult>;
+
+/**
+ * Absolute filesystem path to a JS shim that runs ripgrep via `ripgrep`.
+ * Useful for tools that expect an `rgPath`-style binary path (e.g.
+ * `vscode-ripgrep`-compatible consumers).
+ */
+export const rgPath: string;

package/lib/index.mjs

@@ -0,0 +1,71 @@
+import { fileURLToPath } from "node:url";
+
+export const rgPath = fileURLToPath(new URL("./rg.mjs", import.meta.url));
+
+export async function ripgrep(args = [], options = {}) {
+  const {
+    env = process.env,
+    preopens = { ".": process.cwd() },
+    returnOnExit = true,
+    nodeWasi = process.env.ZIGREP_NODE_WASI === "1",
+  } = options;
+
+  // ripgrep's TTY auto-detection doesn't work through WASI preview1, so it
+  // defaults to --color=never. If the host stdout is a TTY and the caller
+  // hasn't picked a color mode themselves, force ANSI colors on.
+  const hasColorFlag = args.some(
+    (a) => a === "--color" || a.startsWith("--color=") || a === "--no-color",
+  );
+  if (!hasColorFlag && process.stdout.isTTY) {
+    args = ["--color=ansi", ...args];
+  }
+
+  const wasi = await (nodeWasi ? createNodeWasi : createWasiShim)({
+    args,
+    env,
+    preopens,
+    returnOnExit,
+  });
+
+  const wasm = await getRgWasmModule();
+  const instance = await WebAssembly.instantiate(wasm, wasi.imports);
+  const code = await wasi.start(instance);
+  return { code };
+}
+
+// Compiling the wasm module is expensive; cache it so repeated `ripgrep` calls
+// only pay the cost once. Instances are still created per-call since they're
+// stateful (own memory, wasi context, etc).
+let rgWasmModulePromise;
+function getRgWasmModule() {
+  if (!rgWasmModulePromise) {
+    rgWasmModulePromise = import("./_rg.wasm.mjs").then(({ getRgWasmBytes }) =>
+      WebAssembly.compile(getRgWasmBytes()),
+    );
+  }
+  return rgWasmModulePromise;
+}
+
+// Custom WASI preview1 shim (see `_wasi.mjs`). Lazy-imported so consumers
+// that only touch `rgPath` don't pay for loading it.
+async function createWasiShim({ args, env, preopens, returnOnExit }) {
+  const { createWasi } = await import("./_wasi.mjs");
+  return createWasi({ args: ["rg", ...args], env, preopens, returnOnExit });
+}
+
+// Thin adapter over Node's built-in `node:wasi` (https://nodejs.org/api/wasi.html)
+// so it plugs into the same `{ imports, start }` shape as the custom shim.
+async function createNodeWasi({ args, env, preopens, returnOnExit }) {
+  const { WASI } = await import("node:wasi");
+  const wasi = new WASI({
+    version: "preview1",
+    args: ["rg", ...args],
+    env,
+    preopens,
+    returnOnExit,
+  });
+  return {
+    imports: wasi.getImportObject(),
+    start: (instance) => wasi.start(instance) ?? 0,
+  };
+}

package/lib/rg.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import module from "node:module";
+module.enableCompileCache?.();
+
+const { ripgrep } = await import("./index.mjs");
+let argv = process.argv.slice(2);
+const { code } = await ripgrep(argv);
+process.exit(code ?? 0);