@smthrs/std 1.0.0-rc.7 → 1.0.0-rc.9

package/dist/cjs/RemoteSearch.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The search contract for a tree on another machine, in two round trips.
+ *
+ * `PortableSearch` asks `FileSystem` one question per directory, per entry
+ * and per file. On a machine reached through a transport, such as a
+ * benchmark's task container behind `docker exec`, every question is a
+ * process start, so one `grep` over a 6,000-file repository is some 20,000 of
+ * them. This peer asks the machine's own shell twice instead. `find` lists
+ * the tree under the root, leaving out the directories every walk skips, and
+ * `tar` returns its `.gitignore` files with the listing. The in-process peer
+ * then decides which files the search reads, a second `tar` returns exactly
+ * those, and `PortableSearch` answers over that copy. Every result, notice,
+ * and refusal is therefore the in-process peer's own: this module decides
+ * only where the bytes come from.
+ *
+ * It runs through the machine's own `ChildProcessSpawner`, the one
+ * `Sandbox.hostContext` serves beside the machine's `FileSystem`. The machine
+ * needs `sh`, `find`, `xargs`, `tar`, `head`, and `base64`; GNU, BusyBox, and
+ * BSD userlands all have them. Output crosses as base64, so a transport whose
+ * channel carries only text returns it intact. A search reads at most
+ * {@link maxBytes} of file content and refuses beyond that, naming the root
+ * to narrow.
+ *
+ * @since 1.0.0-rc.8
+ */
+import type * as ChildProcessSpawner from "@smthrs/kernel/ChildProcessSpawner";
+import * as Path from "@smthrs/kernel/Path";
+import { Context } from "effect";
+import * as Search from "./Search.ts";
+/**
+ * The most file content one search brings back from the machine.
+ *
+ * The copy is held in memory while the in-process peer reads it, so the
+ * bound is on this process's memory rather than on the search: a root that
+ * holds more is refused with `response_too_large` and a narrower root or
+ * globs answer it.
+ *
+ * @category constants
+ * @since 1.0.0-rc.8
+ */
+export declare const maxBytes: number;
+/**
+ * Builds the peer over a machine's spawner and its `Path`, which resolves a
+ * relative root where the machine's file operations do. `maxBytes` lowers
+ * the bound on the file content one search brings back; the default is
+ * {@link maxBytes}.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.8
+ */
+export declare const make: (services: Context.Context<ChildProcessSpawner.ChildProcessSpawner | Path.Path>, options?: {
+    readonly maxBytes?: number | undefined;
+}) => Search.Search;
+//# sourceMappingURL=RemoteSearch.d.ts.map

package/dist/cjs/RemoteSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteSearch.d.ts","sourceRoot":"","sources":["../../src/RemoteSearch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,KAAK,mBAAmB,MAAM,oCAAoC,CAAA;AAC9E,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAA;AAC3C,OAAO,EAAE,OAAO,EAAU,MAAM,QAAQ,CAAA;AASxC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAGrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,QAAoB,CAAA;AA+FzC;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GACf,UAAU,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,mBAAmB,GAAG,IAAI,CAAC,IAAI,CAAC,EAC9E,UAAU;IAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,KACnD,MAAM,CAAC,MAwCT,CAAA"}

package/dist/cjs/RemoteSearch.js

@@ -0,0 +1,134 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RemoteSearch_exports = {};
+__export(RemoteSearch_exports, {
+  make: () => make,
+  maxBytes: () => maxBytes
+});
+module.exports = __toCommonJS(RemoteSearch_exports);
+var Path = __toESM(require("@smthrs/kernel/Path"), 1);
+var import_effect = require("effect");
+var Base64 = __toESM(require("effect/encoding/Base64"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Result = __toESM(require("effect/Result"), 1);
+var Exec = __toESM(require("./internal/Exec.js"), 1);
+var Prune = __toESM(require("./internal/Prune.js"), 1);
+var RemoteTree = __toESM(require("./internal/RemoteTree.js"), 1);
+var Tar = __toESM(require("./internal/Tar.js"), 1);
+var PortableSearch = __toESM(require("./PortableSearch.js"), 1);
+var Search = __toESM(require("./Search.js"), 1);
+var StdError = __toESM(require("./StdError.js"), 1);
+const maxBytes = 256 * 1024 * 1024;
+const maxListingBytes = 64 * 1024 * 1024;
+const quoted = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
+const pruned = `\\( ${Prune.repositoryDirectories.map((name) => `-name ${quoted(name)}`).join(" -o ")} \\) -prune`;
+const missing = (tool) => `searching this machine needs ${tool}, which it does not have`;
+const requireTools = `for t in find xargs tar head; do command -v "$t" >/dev/null || { echo "${missing("$t")}" >&2; exit 3; }; done`;
+const listing = [
+  "set -f",
+  requireTools,
+  "r=$1",
+  "{",
+  `  if [ -d "$r" ]; then if [ -r "$r" ] && [ -x "$r" ]; then printf 'd%s\\0' "$r"; else printf 'u%s\\0' "$r"; fi`,
+  `  elif [ -f "$r" ]; then printf 'f%s\\0' "$r"`,
+  `  elif [ -e "$r" ]; then printf 'o%s\\0' "$r"`,
+  "  fi",
+  // No `-exec … {} +` inside parentheses: BusyBox `find` never runs one there.
+  `  find -H "$r" -mindepth 1 ${pruned} -o -type d -exec printf 'd%s\\0' {} + -o -type f -exec printf 'f%s\\0' {} + -o -type l -exec sh -c 'for p do if [ -d "$p" ]; then k=D; elif [ -f "$p" ]; then k=F; else k=L; fi; printf "%s%s\\0" "$k" "$p"; done' sh {} + -o -exec printf 'o%s\\0' {} + 2>/dev/null`,
+  "  printf 'E\\0'",
+  `  if [ "$3" = 1 ]; then find -H "$r" -mindepth 1 ${pruned} -o -type f -name .gitignore -print0 2>/dev/null | (cd / && COPYFILE_DISABLE=1 xargs -0 -r tar -cf - -- 2>/dev/null); fi`,
+  '} | head -c "$2" | base64'
+].join("\n");
+const fetching = [
+  requireTools,
+  'cd / && COPYFILE_DISABLE=1 xargs -0 -r tar -chf - -- 2>/dev/null | head -c "$1" | base64'
+].join("\n");
+const failed = (root, reason) => new StdError.StdError({
+  code: "command_failed",
+  message: `Could not search ${root} on this machine: ${reason}`,
+  path: root
+});
+const tooLarge = (root, bound) => new StdError.StdError({
+  code: "response_too_large",
+  message: `The files under ${root} come to more than ${bound} bytes; narrow the root or the globs`,
+  path: root
+});
+const bootstrap = `command -v base64 >/dev/null || { echo "${missing("base64")}" >&2; exit 3; }; IFS= read -r p && p=$(printf %s "$p" | base64 -d) && exec sh -c "$p" sh "$@"`;
+const run = (root, script, args, bound, stdin = "") => import_effect.Effect.gen(function* () {
+  const result = yield* Exec.exec("sh", {
+    args: ["-c", bootstrap, "sh", ...args],
+    stdin: `${Base64.encode(new TextEncoder().encode(script))}
+${stdin}`
+  }).pipe(import_effect.Effect.mapError((error) => failed(root, error.message)));
+  if (result.exitCode !== 0) {
+    return yield* import_effect.Effect.fail(failed(root, result.stderr.trim() || `exit ${result.exitCode}`));
+  }
+  const decoded = Base64.decode(result.stdout.replaceAll(/\s/g, ""));
+  if (Result.isFailure(decoded)) return yield* import_effect.Effect.fail(failed(root, "the machine answered with invalid base64"));
+  if (decoded.success.length >= bound) return yield* import_effect.Effect.fail(tooLarge(root, bound - 1));
+  return decoded.success;
+});
+const make = (services, options) => {
+  const path = import_effect.Context.get(services, Path.Path);
+  const contentBound = (options?.maxBytes ?? maxBytes) + 1;
+  const copy = (tree) => import_effect.Context.make(FileSystem.FileSystem, RemoteTree.fileSystem(tree, path)).pipe(import_effect.Context.add(Path.Path, path));
+  const listed = (root, noIgnore) => {
+    const resolved = path.resolve(root);
+    const bound = maxListingBytes + 1;
+    return import_effect.Effect.flatMap(
+      run(root, listing, [resolved, String(bound), noIgnore === true ? "0" : "1"], bound),
+      (bytes) => {
+        const tree = RemoteTree.parse(bytes, resolved, path);
+        return tree === void 0 ? import_effect.Effect.fail(failed(root, "the listing came back malformed")) : import_effect.Effect.succeed(tree);
+      }
+    );
+  };
+  return Search.make({
+    grep: (input) => import_effect.Effect.gen(function* () {
+      const tree = yield* listed(input.root, input.noIgnore);
+      const read = yield* PortableSearch.searched(input).pipe(import_effect.Effect.provide(copy(tree)));
+      const files = [...new Set(read.map((file) => path.resolve(file)))];
+      const bytes = files.length === 0 ? new Uint8Array() : yield* run(
+        input.root,
+        fetching,
+        [String(contentBound)],
+        contentBound,
+        files.map((file) => `${file}\0`).join("")
+      );
+      const members = files.length === 0 || bytes.length > 0 ? Tar.files(bytes) : void 0;
+      if (members === void 0) return yield* import_effect.Effect.fail(failed(input.root, "the files came back malformed"));
+      const contents = new Map([...tree.contents, ...RemoteTree.absolute(members)]);
+      return yield* PortableSearch.make(copy({ ...tree, contents })).grep(input);
+    }).pipe(import_effect.Effect.provide(services)),
+    glob: (input) => import_effect.Effect.flatMap(listed(input.root, input.noIgnore), (tree) => PortableSearch.make(copy(tree)).glob(input)).pipe(
+      import_effect.Effect.provide(services)
+    )
+  });
+};
+//# sourceMappingURL=RemoteSearch.js.map

package/dist/cjs/RemoteSearch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/RemoteSearch.ts"],
+  "sourcesContent": ["/**\n * The search contract for a tree on another machine, in two round trips.\n *\n * `PortableSearch` asks `FileSystem` one question per directory, per entry\n * and per file. On a machine reached through a transport, such as a\n * benchmark's task container behind `docker exec`, every question is a\n * process start, so one `grep` over a 6,000-file repository is some 20,000 of\n * them. This peer asks the machine's own shell twice instead. `find` lists\n * the tree under the root, leaving out the directories every walk skips, and\n * `tar` returns its `.gitignore` files with the listing. The in-process peer\n * then decides which files the search reads, a second `tar` returns exactly\n * those, and `PortableSearch` answers over that copy. Every result, notice,\n * and refusal is therefore the in-process peer's own: this module decides\n * only where the bytes come from.\n *\n * It runs through the machine's own `ChildProcessSpawner`, the one\n * `Sandbox.hostContext` serves beside the machine's `FileSystem`. The machine\n * needs `sh`, `find`, `xargs`, `tar`, `head`, and `base64`; GNU, BusyBox, and\n * BSD userlands all have them. Output crosses as base64, so a transport whose\n * channel carries only text returns it intact. A search reads at most\n * {@link maxBytes} of file content and refuses beyond that, naming the root\n * to narrow.\n *\n * @since 1.0.0-rc.8\n */\n\nimport type * as ChildProcessSpawner from \"@smthrs/kernel/ChildProcessSpawner\"\nimport * as Path from \"@smthrs/kernel/Path\"\nimport { Context, Effect } from \"effect\"\nimport * as Base64 from \"effect/encoding/Base64\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport * as Result from \"effect/Result\"\nimport * as Exec from \"./internal/Exec.ts\"\nimport * as Prune from \"./internal/Prune.ts\"\nimport * as RemoteTree from \"./internal/RemoteTree.ts\"\nimport * as Tar from \"./internal/Tar.ts\"\nimport * as PortableSearch from \"./PortableSearch.ts\"\nimport * as Search from \"./Search.ts\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * The most file content one search brings back from the machine.\n *\n * The copy is held in memory while the in-process peer reads it, so the\n * bound is on this process's memory rather than on the search: a root that\n * holds more is refused with `response_too_large` and a narrower root or\n * globs answer it.\n *\n * @category constants\n * @since 1.0.0-rc.8\n */\nexport const maxBytes = 256 * 1024 * 1024\n\n/** The most a listing, with its `.gitignore` files, may take. */\nconst maxListingBytes = 64 * 1024 * 1024\n\nconst quoted = (value: string): string => `'${value.replaceAll(\"'\", `'\\\\''`)}'`\n\nconst pruned = `\\\\( ${Prune.repositoryDirectories.map((name) => `-name ${quoted(name)}`).join(\" -o \")} \\\\) -prune`\n\n/** The refusal for a machine without one of the tools a search runs. */\nconst missing = (tool: string) => `searching this machine needs ${tool}, which it does not have`\n\nconst requireTools = `for t in find xargs tar head; do command -v \"$t\" >/dev/null || { ` +\n  `echo \"${missing(\"$t\")}\" >&2; exit 3; }; done`\n\n/**\n * `$1` is the root, `$2` the byte bound, and `$3` is `1` to send the\n * `.gitignore` files after the listing. Records are NUL-terminated `<kind><path>`;\n * an `E` record ends the listing, and a tar stream of the ignore files follows.\n */\nconst listing = [\n  \"set -f\",\n  requireTools,\n  \"r=$1\",\n  \"{\",\n  \"  if [ -d \\\"$r\\\" ]; then if [ -r \\\"$r\\\" ] && [ -x \\\"$r\\\" ]; then printf 'd%s\\\\0' \\\"$r\\\"; else printf 'u%s\\\\0' \\\"$r\\\"; fi\",\n  \"  elif [ -f \\\"$r\\\" ]; then printf 'f%s\\\\0' \\\"$r\\\"\",\n  \"  elif [ -e \\\"$r\\\" ]; then printf 'o%s\\\\0' \\\"$r\\\"\",\n  \"  fi\",\n  // No `-exec \u2026 {} +` inside parentheses: BusyBox `find` never runs one there.\n  `  find -H \"$r\" -mindepth 1 ${pruned} -o -type d -exec printf 'd%s\\\\0' {} + ` +\n  `-o -type f -exec printf 'f%s\\\\0' {} + ` +\n  `-o -type l -exec sh -c 'for p do if [ -d \"$p\" ]; then k=D; elif [ -f \"$p\" ]; then k=F; else k=L; fi; ` +\n  `printf \"%s%s\\\\0\" \"$k\" \"$p\"; done' sh {} + -o -exec printf 'o%s\\\\0' {} + 2>/dev/null`,\n  \"  printf 'E\\\\0'\",\n  `  if [ \"$3\" = 1 ]; then find -H \"$r\" -mindepth 1 ${pruned} -o -type f -name .gitignore -print0 2>/dev/null | ` +\n  \"(cd / && COPYFILE_DISABLE=1 xargs -0 -r tar -cf - -- 2>/dev/null); fi\",\n  \"} | head -c \\\"$2\\\" | base64\"\n].join(\"\\n\")\n\n/** `$1` is the byte bound; standard input is the NUL-terminated absolute paths to send. */\nconst fetching = [\n  requireTools,\n  \"cd / && COPYFILE_DISABLE=1 xargs -0 -r tar -chf - -- 2>/dev/null | head -c \\\"$1\\\" | base64\"\n].join(\"\\n\")\n\nconst failed = (root: string, reason: string): StdError.StdError =>\n  new StdError.StdError({\n    code: \"command_failed\",\n    message: `Could not search ${root} on this machine: ${reason}`,\n    path: root\n  })\n\nconst tooLarge = (root: string, bound: number): StdError.StdError =>\n  new StdError.StdError({\n    code: \"response_too_large\",\n    message: `The files under ${root} come to more than ${bound} bytes; narrow the root or the globs`,\n    path: root\n  })\n\n/**\n * Reads the program from the first line of standard input, as base64, and\n * runs it with the arguments and the rest of standard input. A program in\n * the argv would be quoted once by the spawner and again by the transport,\n * and a sealed host refuses to start a command line past 4,096 characters;\n * this line stays short whatever the program says.\n */\nconst bootstrap = `command -v base64 >/dev/null || { echo \"${missing(\"base64\")}\" >&2; exit 3; }; ` +\n  \"IFS= read -r p && p=$(printf %s \\\"$p\\\" | base64 -d) && exec sh -c \\\"$p\\\" sh \\\"$@\\\"\"\n\n/**\n * Runs one script on the machine and decodes the base64 it prints, refusing\n * output that reached `bound`: `head` cut it, so it is not the whole answer.\n */\nconst run = (\n  root: string,\n  script: string,\n  args: ReadonlyArray<string>,\n  bound: number,\n  stdin = \"\"\n): Effect.Effect<Uint8Array, StdError.StdError, ChildProcessSpawner.ChildProcessSpawner> =>\n  Effect.gen(function*() {\n    const result = yield* Exec.exec(\"sh\", {\n      args: [\"-c\", bootstrap, \"sh\", ...args],\n      stdin: `${Base64.encode(new TextEncoder().encode(script))}\\n${stdin}`\n    }).pipe(Effect.mapError((error) => failed(root, error.message)))\n    if (result.exitCode !== 0) {\n      return yield* Effect.fail(failed(root, result.stderr.trim() || `exit ${result.exitCode}`))\n    }\n    const decoded = Base64.decode(result.stdout.replaceAll(/\\s/g, \"\"))\n    if (Result.isFailure(decoded)) return yield* Effect.fail(failed(root, \"the machine answered with invalid base64\"))\n    if (decoded.success.length >= bound) return yield* Effect.fail(tooLarge(root, bound - 1))\n    return decoded.success\n  })\n\n/**\n * Builds the peer over a machine's spawner and its `Path`, which resolves a\n * relative root where the machine's file operations do. `maxBytes` lowers\n * the bound on the file content one search brings back; the default is\n * {@link maxBytes}.\n *\n * @category constructors\n * @since 1.0.0-rc.8\n */\nexport const make = (\n  services: Context.Context<ChildProcessSpawner.ChildProcessSpawner | Path.Path>,\n  options?: { readonly maxBytes?: number | undefined }\n): Search.Search => {\n  const path = Context.get(services, Path.Path)\n  const contentBound = (options?.maxBytes ?? maxBytes) + 1\n  const copy = (tree: RemoteTree.Tree) =>\n    Context.make(FileSystem.FileSystem, RemoteTree.fileSystem(tree, path)).pipe(Context.add(Path.Path, path))\n  const listed = (root: string, noIgnore: boolean | undefined) => {\n    const resolved = path.resolve(root)\n    const bound = maxListingBytes + 1\n    return Effect.flatMap(\n      run(root, listing, [resolved, String(bound), noIgnore === true ? \"0\" : \"1\"], bound),\n      (bytes) => {\n        const tree = RemoteTree.parse(bytes, resolved, path)\n        return tree === undefined ? Effect.fail(failed(root, \"the listing came back malformed\")) : Effect.succeed(tree)\n      }\n    )\n  }\n  return Search.make({\n    grep: (input) =>\n      Effect.gen(function*() {\n        const tree = yield* listed(input.root, input.noIgnore)\n        const read = yield* PortableSearch.searched(input).pipe(Effect.provide(copy(tree)))\n        const files = [...new Set(read.map((file) => path.resolve(file)))]\n        const bytes = files.length === 0 ? new Uint8Array() : yield* run(\n          input.root,\n          fetching,\n          [String(contentBound)],\n          contentBound,\n          files.map((file) => `${file}\\0`).join(\"\")\n        )\n        // `tar` ends every archive it writes, even one whose files it could not read.\n        const members = files.length === 0 || bytes.length > 0 ? Tar.files(bytes) : undefined\n        if (members === undefined) return yield* Effect.fail(failed(input.root, \"the files came back malformed\"))\n        const contents = new Map([...tree.contents, ...RemoteTree.absolute(members)])\n        return yield* PortableSearch.make(copy({ ...tree, contents })).grep(input)\n      }).pipe(Effect.provide(services)),\n    glob: (input) =>\n      Effect.flatMap(listed(input.root, input.noIgnore), (tree) => PortableSearch.make(copy(tree)).glob(input)).pipe(\n        Effect.provide(services)\n      )\n  })\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -44,6 +44,8 @@ export * as SearchConformance from "./SearchConformance.ts";
 export * as PortableSearch from "./PortableSearch.ts";
 /** @category layers @since 1.0.0 */
 export * as NativeSearch from "./NativeSearch.ts";
+/** @category layers @since 1.0.0-rc.8 */
+export * as RemoteSearch from "./RemoteSearch.ts";
 /**
  * @category flows
  * @since 1.0.0

package/dist/cjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAA;AAE7B;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,sCAAsC;AACtC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,sCAAsC;AACtC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD,yCAAyC;AACzC,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D,oCAAoC;AACpC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD,oCAAoC;AACpC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,sCAAsC;AACtC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;GAGG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD,sCAAsC;AACtC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C,yCAAyC;AACzC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,sCAAsC;AACtC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,mCAAmC;AACnC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,mCAAmC;AACnC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,sCAAsC;AACtC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD,sCAAsC;AACtC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,oCAAoC;AACpC,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,mCAAmC;AACnC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA;AAE/B;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAA;AAE7B;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,sCAAsC;AACtC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,sCAAsC;AACtC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD,yCAAyC;AACzC,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D,oCAAoC;AACpC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD,oCAAoC;AACpC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD,yCAAyC;AACzC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,sCAAsC;AACtC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;GAGG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD,sCAAsC;AACtC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C,yCAAyC;AACzC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,sCAAsC;AACtC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC,mCAAmC;AACnC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,mCAAmC;AACnC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,sCAAsC;AACtC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD,sCAAsC;AACtC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,oCAAoC;AACpC,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,mCAAmC;AACnC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA;AAE/B;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA"}

package/dist/cjs/index.js

@@ -49,6 +49,7 @@ __export(index_exports, {
   Probe: () => Probe,
   Read: () => Read,
   Relocate: () => Relocate,
+  RemoteSearch: () => RemoteSearch,
   Search: () => Search,
   SearchConformance: () => SearchConformance,
   SearchContract: () => SearchContract,
@@ -74,6 +75,7 @@ var SearchContract = __toESM(require("./SearchContract.js"), 1);
 var SearchConformance = __toESM(require("./SearchConformance.js"), 1);
 var PortableSearch = __toESM(require("./PortableSearch.js"), 1);
 var NativeSearch = __toESM(require("./NativeSearch.js"), 1);
+var RemoteSearch = __toESM(require("./RemoteSearch.js"), 1);
 var Bash = __toESM(require("./Bash.js"), 1);
 var Container = __toESM(require("./Container.js"), 1);
 var TreeFingerprint = __toESM(require("./TreeFingerprint.js"), 1);

package/dist/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["/**\n * `@smthrs/std`: the standard coding tools expressed as flows, the host\n * services they bind, and the one error they share.\n *\n * @since 1.0.0\n */\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Read from \"./Read.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Write from \"./Write.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Edit from \"./Edit.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Ls from \"./Ls.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Glob from \"./Glob.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Grep from \"./Grep.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as Search from \"./Search.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as SearchContract from \"./SearchContract.ts\"\n\n/** @category conformance @since 1.0.0 */\nexport * as SearchConformance from \"./SearchConformance.ts\"\n\n/** @category layers @since 1.0.0 */\nexport * as PortableSearch from \"./PortableSearch.ts\"\n\n/** @category layers @since 1.0.0 */\nexport * as NativeSearch from \"./NativeSearch.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Bash from \"./Bash.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as Container from \"./Container.ts\"\n\n/**\n * @category measurement\n * @since 1.0.0\n */\nexport * as TreeFingerprint from \"./TreeFingerprint.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as Checkpoints from \"./Checkpoints.ts\"\n\n/** @category conversions @since 1.0.0 */\nexport * as Relocate from \"./Relocate.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as TestRun from \"./TestRun.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as TestRunner from \"./TestRunner.ts\"\n\n/**\n * @category classification\n * @since 1.0.0\n */\nexport * as Probe from \"./Probe.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as ApplyPatch from \"./ApplyPatch.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as ShellCommand from \"./ShellCommand.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as UpdatePlan from \"./UpdatePlan.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Fetch from \"./Fetch.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as HttpPost from \"./HttpPost.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Explore from \"./Explore.ts\"\n\n/** @category flows @since 1.0.0 */\nexport * as WebFetch from \"./WebFetch.ts\"\n/** @category flows @since 1.0.0 */\nexport * as WebSearch from \"./WebSearch.ts\"\n/** @category services @since 1.0.0 */\nexport * as ExaWebSearch from \"./ExaWebSearch.ts\"\n/** @category services @since 1.0.0 */\nexport * as LanguageServer from \"./LanguageServer.ts\"\n/** @category layers @since 1.0.0 */\nexport * as NodeLanguageServer from \"./NodeLanguageServer.ts\"\n/** @category flows @since 1.0.0 */\nexport * as Lsp from \"./Lsp.ts\"\n\n/**\n * @category registries\n * @since 1.0.0\n */\nexport * as Manifest from \"./Manifest.ts\"\n\n/**\n * @category errors\n * @since 1.0.0\n */\nexport * as StdError from \"./StdError.ts\"\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,WAAsB;AAMtB,YAAuB;AAMvB,WAAsB;AAMtB,SAAoB;AAMpB,WAAsB;AAMtB,WAAsB;AAGtB,aAAwB;AAGxB,qBAAgC;AAGhC,wBAAmC;AAGnC,qBAAgC;AAGhC,mBAA8B;AAM9B,WAAsB;AAGtB,gBAA2B;AAM3B,sBAAiC;AAGjC,kBAA6B;AAG7B,eAA0B;AAM1B,cAAyB;AAGzB,iBAA4B;AAM5B,YAAuB;AAMvB,iBAA4B;AAM5B,mBAA8B;AAM9B,iBAA4B;AAM5B,YAAuB;AAMvB,eAA0B;AAM1B,cAAyB;AAGzB,eAA0B;AAE1B,gBAA2B;AAE3B,mBAA8B;AAE9B,qBAAgC;AAEhC,yBAAoC;AAEpC,UAAqB;AAMrB,eAA0B;AAM1B,eAA0B;",
+  "sourcesContent": ["/**\n * `@smthrs/std`: the standard coding tools expressed as flows, the host\n * services they bind, and the one error they share.\n *\n * @since 1.0.0\n */\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Read from \"./Read.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Write from \"./Write.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Edit from \"./Edit.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Ls from \"./Ls.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Glob from \"./Glob.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Grep from \"./Grep.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as Search from \"./Search.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as SearchContract from \"./SearchContract.ts\"\n\n/** @category conformance @since 1.0.0 */\nexport * as SearchConformance from \"./SearchConformance.ts\"\n\n/** @category layers @since 1.0.0 */\nexport * as PortableSearch from \"./PortableSearch.ts\"\n\n/** @category layers @since 1.0.0 */\nexport * as NativeSearch from \"./NativeSearch.ts\"\n\n/** @category layers @since 1.0.0-rc.8 */\nexport * as RemoteSearch from \"./RemoteSearch.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Bash from \"./Bash.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as Container from \"./Container.ts\"\n\n/**\n * @category measurement\n * @since 1.0.0\n */\nexport * as TreeFingerprint from \"./TreeFingerprint.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as Checkpoints from \"./Checkpoints.ts\"\n\n/** @category conversions @since 1.0.0 */\nexport * as Relocate from \"./Relocate.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as TestRun from \"./TestRun.ts\"\n\n/** @category services @since 1.0.0 */\nexport * as TestRunner from \"./TestRunner.ts\"\n\n/**\n * @category classification\n * @since 1.0.0\n */\nexport * as Probe from \"./Probe.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as ApplyPatch from \"./ApplyPatch.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as ShellCommand from \"./ShellCommand.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as UpdatePlan from \"./UpdatePlan.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Fetch from \"./Fetch.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as HttpPost from \"./HttpPost.ts\"\n\n/**\n * @category flows\n * @since 1.0.0\n */\nexport * as Explore from \"./Explore.ts\"\n\n/** @category flows @since 1.0.0 */\nexport * as WebFetch from \"./WebFetch.ts\"\n/** @category flows @since 1.0.0 */\nexport * as WebSearch from \"./WebSearch.ts\"\n/** @category services @since 1.0.0 */\nexport * as ExaWebSearch from \"./ExaWebSearch.ts\"\n/** @category services @since 1.0.0 */\nexport * as LanguageServer from \"./LanguageServer.ts\"\n/** @category layers @since 1.0.0 */\nexport * as NodeLanguageServer from \"./NodeLanguageServer.ts\"\n/** @category flows @since 1.0.0 */\nexport * as Lsp from \"./Lsp.ts\"\n\n/**\n * @category registries\n * @since 1.0.0\n */\nexport * as Manifest from \"./Manifest.ts\"\n\n/**\n * @category errors\n * @since 1.0.0\n */\nexport * as StdError from \"./StdError.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,WAAsB;AAMtB,YAAuB;AAMvB,WAAsB;AAMtB,SAAoB;AAMpB,WAAsB;AAMtB,WAAsB;AAGtB,aAAwB;AAGxB,qBAAgC;AAGhC,wBAAmC;AAGnC,qBAAgC;AAGhC,mBAA8B;AAG9B,mBAA8B;AAM9B,WAAsB;AAGtB,gBAA2B;AAM3B,sBAAiC;AAGjC,kBAA6B;AAG7B,eAA0B;AAM1B,cAAyB;AAGzB,iBAA4B;AAM5B,YAAuB;AAMvB,iBAA4B;AAM5B,mBAA8B;AAM9B,iBAA4B;AAM5B,YAAuB;AAMvB,eAA0B;AAM1B,cAAyB;AAGzB,eAA0B;AAE1B,gBAA2B;AAE3B,mBAA8B;AAE9B,qBAAgC;AAEhC,yBAAoC;AAEpC,UAAqB;AAMrB,eAA0B;AAM1B,eAA0B;",
   "names": []
 }

package/dist/cjs/internal/EnvelopePrecheck.d.ts

@@ -52,6 +52,8 @@ export interface PathReference {
 /**
  * Every path token the shell text names, one segment at a time.
  *
+ * @throws {StdError.StdError} `invalid_input` when substitutions or quotes nest
+ * deeper than the scan reads.
  * @category pre-check
  * @since 1.0.0
  */

package/dist/cjs/internal/EnvelopePrecheck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnvelopePrecheck.d.ts","sourceRoot":"","sources":["../../../src/internal/EnvelopePrecheck.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,KAAK,IAAI,MAAM,qBAAqB,CAAA;AAChD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAG1C;;;;;;;;;GASG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACvC;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAErC;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAwFD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,IAAI,CAAC,IAAI,EAAE,SAAS,MAAM,KAAG,aAAa,CAAC,aAAa,CAa/F,CAAA;AAmBD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,QAAQ,EACf,MAAM,MAAM,EACZ,MAAM,IAAI,CAAC,IAAI,KACd,QAAQ,CAAC,QAAQ,GAAG,SAwCtB,CAAA"}
+{"version":3,"file":"EnvelopePrecheck.d.ts","sourceRoot":"","sources":["../../../src/internal/EnvelopePrecheck.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,KAAK,IAAI,MAAM,qBAAqB,CAAA;AAChD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAG1C;;;;;;;;;GASG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACvC;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAErC;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AA0VD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,IAAI,CAAC,IAAI,EAAE,SAAS,MAAM,KAAG,aAAa,CAAC,aAAa,CAClE,CAAA;AAmB9B;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,QAAQ,EACf,MAAM,MAAM,EACZ,MAAM,IAAI,CAAC,IAAI,KACd,QAAQ,CAAC,QAAQ,GAAG,SAgDtB,CAAA"}

package/dist/cjs/internal/EnvelopePrecheck.js

@@ -34,63 +34,256 @@ __export(EnvelopePrecheck_exports, {
 module.exports = __toCommonJS(EnvelopePrecheck_exports);
 var StdError = __toESM(require("../StdError.js"), 1);
 var import_Paths = require("./Paths.js");
-const commandSeparators = /* @__PURE__ */ new Set(["&&", "||", ";", "|", "&", "\n"]);
-const redirections = /* @__PURE__ */ new Set([">", ">>", "<", "<<"]);
+const commandSeparators = /* @__PURE__ */ new Set(["&&", "||", ";", ";;", ";&", ";;&", "|", "|&", "&", "\n", "(", ")"]);
+const writeRedirections = /* @__PURE__ */ new Set([">", ">>", ">|", "&>", "&>>", ">&", "<>"]);
+const readRedirections = /* @__PURE__ */ new Set(["<", "<&"]);
+const textRedirections = /* @__PURE__ */ new Set(["<<", "<<-", "<<<"]);
+const isRedirection = (token) => token.operator && (writeRedirections.has(token.text) || readRedirections.has(token.text) || textRedirections.has(token.text));
+const operators = [
+  ";;&",
+  "&>>",
+  "<<<",
+  "<<-",
+  ";;",
+  ";&",
+  "&&",
+  "||",
+  "|&",
+  "&>",
+  ">>",
+  ">|",
+  ">&",
+  "<>",
+  "<<",
+  "<&",
+  "\n",
+  ";",
+  "|",
+  "&",
+  "(",
+  ")",
+  ">",
+  "<"
+];
+const reservedWords = /* @__PURE__ */ new Set([
+  "!",
+  "{",
+  "}",
+  "case",
+  "do",
+  "done",
+  "elif",
+  "else",
+  "esac",
+  "fi",
+  "for",
+  "function",
+  "if",
+  "in",
+  "select",
+  "then",
+  "until",
+  "while"
+]);
 const writeCommands = /* @__PURE__ */ new Set(["chmod", "chown", "mkdir", "rm", "rmdir", "tee", "touch", "truncate", "unlink"]);
 const destinationCommands = /* @__PURE__ */ new Set(["cp", "install", "mv"]);
 const prefixWrappers = /* @__PURE__ */ new Set(["env", "nice", "time", "sudo", "nohup", "xargs", "command", "exec"]);
-const tokenize = (command) => command.match(/\n|>>|<<|&&|\|\||[<>;|&]|(?:"(?:\\.|[^"\\])*"|'[^']*'|[^\s<>;|&"']+)+/g) ?? [];
-const unquote = (token) => {
-  const first = token[0];
-  const last = token[token.length - 1];
-  return token.length >= 2 && (first === "'" || first === '"') && last === first ? token.slice(1, -1) : token;
+const shells = /* @__PURE__ */ new Set(["ash", "bash", "dash", "fish", "ksh", "mksh", "sh", "zsh"]);
+const commandFlag = /^-[A-Za-z]*c[A-Za-z]*$/;
+const maxNesting = 32;
+const tooDeep = () => new StdError.StdError({
+  code: "invalid_input",
+  message: `Command nests substitutions or quotes deeper than ${maxNesting} levels`
+});
+const substitutionEnd = (text, from, nesting) => {
+  if (nesting > maxNesting) throw tooDeep();
+  let depth = 1;
+  let index = from;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+    } else if (char === "'") {
+      const close = text.indexOf("'", index + 1);
+      index = close === -1 ? text.length : close + 1;
+    } else if (char === '"') {
+      index = doubleQuoteEnd(text, index + 1, nesting + 1) + 1;
+    } else if (char === "`") {
+      index = backtickEnd(text, index + 1) + 1;
+    } else {
+      if (char === "(") depth++;
+      if (char === ")" && --depth === 0) return index;
+      index++;
+    }
+  }
+  return text.length;
+};
+const backtickEnd = (text, from) => {
+  let index = from;
+  while (index < text.length && text[index] !== "`") index += text[index] === "\\" ? 2 : 1;
+  return Math.min(index, text.length);
+};
+const doubleQuoteEnd = (text, from, nesting) => {
+  if (nesting > maxNesting) throw tooDeep();
+  let index = from;
+  while (index < text.length && text[index] !== '"') {
+    const char = text[index];
+    if (char === "\\") index += 2;
+    else if (char === "`") index = backtickEnd(text, index + 1) + 1;
+    else if (char === "$" && text[index + 1] === "(") index = substitutionEnd(text, index + 2, nesting + 1) + 1;
+    else index++;
+  }
+  return Math.min(index, text.length);
+};
+const descriptorPattern = /\d+(?=[<>])/y;
+const lex = (command, nesting) => {
+  const tokens = [];
+  const substitutions = [];
+  let index = 0;
+  const substitution = (from, to) => {
+    substitutions.push(command.slice(from, to));
+    return "$()";
+  };
+  while (index < command.length) {
+    const char = command[index];
+    if (char !== "\n" && /\s/.test(char)) {
+      index++;
+      continue;
+    }
+    if (char === "\\" && command[index + 1] === "\n") {
+      index += 2;
+      continue;
+    }
+    if (char === "#") {
+      while (index < command.length && command[index] !== "\n") index++;
+      continue;
+    }
+    descriptorPattern.lastIndex = index;
+    const descriptor = descriptorPattern.exec(command);
+    if (descriptor !== null) {
+      index += descriptor[0].length;
+      continue;
+    }
+    const operator = operators.find((candidate) => command.startsWith(candidate, index));
+    if (operator !== void 0) {
+      tokens.push({ operator: true, text: operator });
+      index += operator.length;
+      continue;
+    }
+    let text = "";
+    while (index < command.length) {
+      const next = command[index];
+      if (/[\s<>;|&()]/.test(next)) break;
+      if (next === "\\") {
+        const escaped = command[index + 1] ?? "";
+        if (escaped !== "\n") text += /[\s<>;|&()'"`$\\#]/.test(escaped) ? escaped : `\\${escaped}`;
+        index += 2;
+      } else if (next === "'") {
+        const close = command.indexOf("'", index + 1);
+        const end = close === -1 ? command.length : close;
+        text += command.slice(index + 1, end);
+        index = end + 1;
+      } else if (next === '"') {
+        const end = doubleQuoteEnd(command, index + 1, nesting + 1);
+        let inner = index + 1;
+        while (inner < end) {
+          const quoted = command[inner];
+          if (quoted === "\\" && /[$`"\\\n]/.test(command[inner + 1] ?? "")) {
+            if (command[inner + 1] !== "\n") text += command[inner + 1];
+            inner += 2;
+          } else if (quoted === "`") {
+            const close = backtickEnd(command, inner + 1);
+            text += substitution(inner + 1, close);
+            inner = close + 1;
+          } else if (quoted === "$" && command[inner + 1] === "(") {
+            const close = substitutionEnd(command, inner + 2, nesting + 2);
+            text += substitution(inner + 2, close);
+            inner = close + 1;
+          } else {
+            text += quoted;
+            inner++;
+          }
+        }
+        index = end + 1;
+      } else if (next === "`") {
+        const close = backtickEnd(command, index + 1);
+        text += substitution(index + 1, close);
+        index = close + 1;
+      } else if (next === "$" && command[index + 1] === "(") {
+        const close = substitutionEnd(command, index + 2, nesting + 1);
+        text += substitution(index + 2, close);
+        index = close + 1;
+      } else {
+        text += next;
+        index++;
+      }
+    }
+    tokens.push({ operator: false, text });
+  }
+  return { tokens, substitutions };
 };
-const pathValue = (token) => unquote(token).replace(/^\$\(+/, "").replace(/[),]+$/, "");
+const pathValue = (token) => token.replace(/,+$/, "");
 const isPathToken = (path, token) => token === "." || token === ".." || token.startsWith("./") || token.startsWith("../") || path.isAbsolute(token) || /^[A-Za-z]:[\\/]/.test(token) || token.includes("/");
-const segmentReferences = (path, tokens) => {
-  const commentIndex = tokens.findIndex((token) => token.startsWith("#"));
-  const active = commentIndex === -1 ? tokens : tokens.slice(0, commentIndex);
-  const hasWrapper = active.some((token) => prefixWrappers.has(path.basename(pathValue(token))));
-  let commandIndex = active.findIndex(
-    (token) => !redirections.has(token) && !token.includes("=") && !prefixWrappers.has(path.basename(pathValue(token))) && !token.startsWith("-") && token !== ""
+const segmentReferences = (path, tokens, nesting) => {
+  const isTarget = (index) => index > 0 && isRedirection(tokens[index - 1]);
+  const isWord = (index) => !tokens[index].operator && !isTarget(index);
+  const name = (index) => path.basename(pathValue(tokens[index].text));
+  const hasWrapper = tokens.some((_, index) => isWord(index) && prefixWrappers.has(name(index)));
+  let commandIndex = tokens.findIndex(
+    (token, index) => isWord(index) && !token.text.includes("=") && !prefixWrappers.has(name(index)) && !reservedWords.has(token.text) && !token.text.startsWith("-") && token.text !== ""
   );
   if (hasWrapper) {
-    const mutatingIndex = active.findIndex((token) => {
-      const command2 = path.basename(pathValue(token));
-      return writeCommands.has(command2) || destinationCommands.has(command2);
-    });
+    const mutatingIndex = tokens.findIndex(
+      (_, index) => isWord(index) && (writeCommands.has(name(index)) || destinationCommands.has(name(index)))
+    );
     if (mutatingIndex !== -1) commandIndex = mutatingIndex;
   }
-  if (commandIndex === -1) return [];
-  const command = path.basename(pathValue(active[commandIndex]));
+  const command = commandIndex === -1 ? "" : name(commandIndex);
+  const scripts = /* @__PURE__ */ new Set();
+  if (command === "eval") {
+    for (let index = commandIndex + 1; index < tokens.length; index++) if (isWord(index)) scripts.add(index);
+  } else if (shells.has(command)) {
+    const flag = tokens.findIndex(
+      (token, index) => index > commandIndex && isWord(index) && commandFlag.test(token.text)
+    );
+    if (flag !== -1 && flag + 1 < tokens.length && isWord(flag + 1)) scripts.add(flag + 1);
+  }
   const candidates = [];
-  for (let index = 0; index < active.length; index++) {
-    const token = active[index];
-    if (index === commandIndex || redirections.has(token) || token.startsWith("-")) continue;
-    const value = pathValue(token);
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (index === commandIndex || scripts.has(index) || token.operator) continue;
+    if (!isTarget(index) && token.text.startsWith("-")) continue;
+    if (isTarget(index) && textRedirections.has(tokens[index - 1].text)) continue;
+    const value = pathValue(token.text);
     if (value !== "" && isPathToken(path, value)) candidates.push({ index, value });
   }
-  const destinationIndex = destinationCommands.has(command) ? candidates[candidates.length - 1]?.index : void 0;
-  return candidates.map(({ index, value }) => {
-    const previous = active[index - 1];
-    const access = previous === ">" || previous === ">>" || writeCommands.has(command) || destinationIndex === index ? "write" : "read";
+  const destinationIndex = destinationCommands.has(command) ? candidates.filter(({ index }) => !isTarget(index)).at(-1)?.index : void 0;
+  const script = [...scripts].map((index) => tokens[index].text).join(" ");
+  const nested = script === "" ? [] : references(path, script, nesting + 1);
+  const named = candidates.map(({ index, value }) => {
+    const access = isTarget(index) ? writeRedirections.has(tokens[index - 1].text) ? "write" : "read" : writeCommands.has(command) || destinationIndex === index ? "write" : "read";
     return { access, value };
   });
+  return [...named, ...nested];
 };
-const commandReferences = (path, command) => {
-  const references = [];
+const references = (path, command, nesting) => {
+  if (nesting > maxNesting) throw tooDeep();
+  const { substitutions, tokens } = lex(command, nesting);
+  const found = [];
   let segment = [];
-  for (const token of tokenize(command)) {
-    if (commandSeparators.has(token)) {
-      references.push(...segmentReferences(path, segment));
+  for (const token of tokens) {
+    if (token.operator && commandSeparators.has(token.text)) {
+      found.push(...segmentReferences(path, segment, nesting));
       segment = [];
     } else {
       segment.push(token);
     }
   }
-  references.push(...segmentReferences(path, segment));
-  return references;
+  found.push(...segmentReferences(path, segment, nesting));
+  for (const body of substitutions) found.push(...references(path, body, nesting + 1));
+  return found;
 };
+const commandReferences = (path, command) => references(path, command, 0);
 const resolvePath = (path, cwd, value) => path.isAbsolute(value) ? path.normalize(value) : path.resolve(cwd, value);
 const isDeclared = (path, cwd, declared, source) => (0, import_Paths.withinEnvelope)(
   declared.map((entry) => resolvePath(path, cwd, entry)),
@@ -106,7 +299,13 @@ const outsideEnvelope = (input, text, path) => {
       path: cwd
     });
   }
-  for (const reference of commandReferences(path, text)) {
+  let named;
+  try {
+    named = commandReferences(path, text);
+  } catch {
+    return tooDeep();
+  }
+  for (const reference of named) {
     const resolved = resolvePath(path, cwd, reference.value);
     if (resolved.startsWith("/dev/")) continue;
     const declared = reference.access === "write" ? input.writes : input.reads;