@smthrs/std 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/internal/CodexText.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CodexText_exports = {};
+__export(CodexText_exports, {
+  approxBytesForTokens: () => approxBytesForTokens,
+  approxTokenCount: () => approxTokenCount,
+  approxTokensFromByteCount: () => approxTokensFromByteCount,
+  byteLength: () => byteLength,
+  formatExecOutputForModel: () => formatExecOutputForModel,
+  truncateMiddleChars: () => truncateMiddleChars,
+  truncateMiddleWithTokenBudget: () => truncateMiddleWithTokenBudget
+});
+module.exports = __toCommonJS(CodexText_exports);
+const APPROX_BYTES_PER_TOKEN = 4;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const byteLength = (text) => encoder.encode(text).byteLength;
+const approxTokenCount = (text) => Math.floor((byteLength(text) + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN);
+const approxBytesForTokens = (tokens) => tokens * APPROX_BYTES_PER_TOKEN;
+const approxTokensFromByteCount = (bytes) => Math.floor((bytes + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN);
+const formatTruncationMarker = (useTokens, removedCount) => useTokens ? `\u2026${removedCount} tokens truncated\u2026` : `\u2026${removedCount} chars truncated\u2026`;
+const isContinuation = (byte) => (byte & 192) === 128;
+const boundaryAtOrBefore = (bytes, offset) => {
+  let at = Math.min(offset, bytes.byteLength);
+  while (at > 0 && at < bytes.byteLength && isContinuation(bytes[at])) at--;
+  return at;
+};
+const boundaryAtOrAfter = (bytes, offset) => {
+  let at = Math.max(offset, 0);
+  while (at < bytes.byteLength && isContinuation(bytes[at])) at++;
+  return at;
+};
+const splitString = (s, beginningBytes, endBytes) => {
+  const bytes = encoder.encode(s);
+  const tailStartTarget = Math.max(bytes.byteLength - endBytes, 0);
+  const prefixEnd = boundaryAtOrBefore(bytes, beginningBytes);
+  const suffixStart = boundaryAtOrAfter(bytes, Math.max(tailStartTarget, prefixEnd));
+  let removedChars = 0;
+  for (let at = prefixEnd; at < suffixStart; at++) if (!isContinuation(bytes[at])) removedChars++;
+  return {
+    removedChars,
+    before: decoder.decode(bytes.subarray(0, prefixEnd)),
+    after: decoder.decode(bytes.subarray(suffixStart))
+  };
+};
+const truncateWithByteEstimate = (s, maxBytes, useTokens) => {
+  if (s === "") return "";
+  const totalBytes = byteLength(s);
+  if (maxBytes === 0) {
+    return formatTruncationMarker(useTokens, useTokens ? approxTokensFromByteCount(totalBytes) : [...s].length);
+  }
+  if (totalBytes <= maxBytes) return s;
+  const leftBudget = Math.floor(maxBytes / 2);
+  const rightBudget = maxBytes - leftBudget;
+  const { after, before, removedChars } = splitString(s, leftBudget, rightBudget);
+  const marker = formatTruncationMarker(
+    useTokens,
+    useTokens ? approxTokensFromByteCount(Math.max(totalBytes - maxBytes, 0)) : removedChars
+  );
+  return `${before}${marker}${after}`;
+};
+const truncateMiddleChars = (s, maxBytes) => truncateWithByteEstimate(s, maxBytes, false);
+const truncateMiddleWithTokenBudget = (s, maxTokens) => {
+  if (s === "") return { text: "", originalTokenCount: void 0 };
+  if (maxTokens > 0 && byteLength(s) <= approxBytesForTokens(maxTokens)) {
+    return { text: s, originalTokenCount: void 0 };
+  }
+  const truncated = truncateWithByteEstimate(s, approxBytesForTokens(maxTokens), true);
+  if (truncated === s) return { text: s, originalTokenCount: void 0 };
+  return { text: truncated, originalTokenCount: approxTokenCount(s) };
+};
+const countLines = (content) => {
+  if (content === "") return 0;
+  const parts = content.split("\n");
+  return parts[parts.length - 1] === "" ? parts.length - 1 : parts.length;
+};
+const formatExecOutputForModel = (options) => {
+  const content = options.timedOutAfterMs === void 0 ? options.output : `command timed out after ${options.timedOutAfterMs} milliseconds
+${options.output}`;
+  const durationSeconds = Math.round(options.durationSeconds * 10) / 10;
+  const totalLines = countLines(content);
+  const formatted = truncateMiddleWithTokenBudget(content, options.maxOutputTokens).text;
+  const sections = [
+    `Exit code: ${options.exitCode}`,
+    `Wall time: ${durationSeconds} seconds`
+  ];
+  if (totalLines !== countLines(formatted)) sections.push(`Total output lines: ${totalLines}`);
+  sections.push("Output:");
+  sections.push(formatted);
+  return sections.join("\n");
+};
+//# sourceMappingURL=CodexText.js.map

package/dist/cjs/internal/CodexText.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/CodexText.ts"],
+  "sourcesContent": ["/**\n * Faithful port of Codex CLI output truncation.\n *\n * Mirrors `codex-rs/utils/string/src/truncate.rs` and\n * `codex-rs/utils/output-truncation/src/lib.rs`: middle truncation on UTF-8\n * boundaries with a `\u2026{n} tokens truncated\u2026` marker and a 4-bytes-per-token\n * estimate, so ChatGPT-family models see the exact shapes they were\n * posttrained on.\n *\n * @since 1.0.0\n */\n\nconst APPROX_BYTES_PER_TOKEN = 4\n\nconst encoder = new TextEncoder()\nconst decoder = new TextDecoder()\n\n/**\n * UTF-8 byte length of a string.\n *\n * @since 1.0.0\n * @private\n */\nexport const byteLength = (text: string): number => encoder.encode(text).byteLength\n\n/**\n * Approximate token count: ceil(utf8Bytes / 4).\n *\n * @since 1.0.0\n * @private\n */\nexport const approxTokenCount = (text: string): number =>\n  Math.floor((byteLength(text) + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN)\n\n/**\n * Approximate byte budget for a token budget.\n *\n * @since 1.0.0\n * @private\n */\nexport const approxBytesForTokens = (tokens: number): number => tokens * APPROX_BYTES_PER_TOKEN\n\n/**\n * Approximate tokens represented by a byte count: ceil(bytes / 4).\n *\n * @since 1.0.0\n * @private\n */\nexport const approxTokensFromByteCount = (bytes: number): number =>\n  Math.floor((bytes + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN)\n\nconst formatTruncationMarker = (useTokens: boolean, removedCount: number): string =>\n  useTokens ? `\u2026${removedCount} tokens truncated\u2026` : `\u2026${removedCount} chars truncated\u2026`\n\ninterface Split {\n  readonly removedChars: number\n  readonly before: string\n  readonly after: string\n}\n\n/** A UTF-8 continuation byte is `10xxxxxx`; every other byte starts a character. */\nconst isContinuation = (byte: number): boolean => (byte & 0b1100_0000) === 0b1000_0000\n\n/** The last character boundary at or before `offset`. */\nconst boundaryAtOrBefore = (bytes: Uint8Array, offset: number): number => {\n  let at = Math.min(offset, bytes.byteLength)\n  while (at > 0 && at < bytes.byteLength && isContinuation(bytes[at]!)) at--\n  return at\n}\n\n/** The first character boundary at or after `offset`. */\nconst boundaryAtOrAfter = (bytes: Uint8Array, offset: number): number => {\n  let at = Math.max(offset, 0)\n  while (at < bytes.byteLength && isContinuation(bytes[at]!)) at++\n  return at\n}\n\n/**\n * Splits `s` into the head that fits `beginningBytes` and the tail that fits\n * `endBytes`, both cut on UTF-8 character boundaries, and counts the characters\n * dropped between them.\n *\n * The boundaries are read off the encoded bytes rather than by re-encoding one\n * character at a time: a per-character `TextEncoder.encode` costs about two\n * microseconds, which is nineteen seconds for the eight megabytes a bounded\n * capture can hand this function.\n */\nconst splitString = (s: string, beginningBytes: number, endBytes: number): Split => {\n  const bytes = encoder.encode(s)\n  const tailStartTarget = Math.max(bytes.byteLength - endBytes, 0)\n  const prefixEnd = boundaryAtOrBefore(bytes, beginningBytes)\n  const suffixStart = boundaryAtOrAfter(bytes, Math.max(tailStartTarget, prefixEnd))\n  let removedChars = 0\n  for (let at = prefixEnd; at < suffixStart; at++) if (!isContinuation(bytes[at]!)) removedChars++\n  return {\n    removedChars,\n    before: decoder.decode(bytes.subarray(0, prefixEnd)),\n    after: decoder.decode(bytes.subarray(suffixStart))\n  }\n}\n\nconst truncateWithByteEstimate = (s: string, maxBytes: number, useTokens: boolean): string => {\n  if (s === \"\") return \"\"\n  const totalBytes = byteLength(s)\n  if (maxBytes === 0) {\n    return formatTruncationMarker(useTokens, useTokens ? approxTokensFromByteCount(totalBytes) : [...s].length)\n  }\n  if (totalBytes <= maxBytes) return s\n  const leftBudget = Math.floor(maxBytes / 2)\n  const rightBudget = maxBytes - leftBudget\n  const { after, before, removedChars } = splitString(s, leftBudget, rightBudget)\n  const marker = formatTruncationMarker(\n    useTokens,\n    useTokens ? approxTokensFromByteCount(Math.max(totalBytes - maxBytes, 0)) : removedChars\n  )\n  return `${before}${marker}${after}`\n}\n\n/**\n * Middle-truncate to a byte budget with a char-count marker.\n *\n * @since 1.0.0\n * @private\n */\nexport const truncateMiddleChars = (s: string, maxBytes: number): string => truncateWithByteEstimate(s, maxBytes, false)\n\n/**\n * Middle-truncate to an approximate token budget, preserving the beginning\n * and end. Returns the possibly truncated string and the original token\n * count when truncation occurred.\n *\n * @since 1.0.0\n * @private\n */\nexport const truncateMiddleWithTokenBudget = (\n  s: string,\n  maxTokens: number\n): { readonly text: string; readonly originalTokenCount: number | undefined } => {\n  if (s === \"\") return { text: \"\", originalTokenCount: undefined }\n  if (maxTokens > 0 && byteLength(s) <= approxBytesForTokens(maxTokens)) {\n    return { text: s, originalTokenCount: undefined }\n  }\n  const truncated = truncateWithByteEstimate(s, approxBytesForTokens(maxTokens), true)\n  if (truncated === s) return { text: s, originalTokenCount: undefined }\n  return { text: truncated, originalTokenCount: approxTokenCount(s) }\n}\n\nconst countLines = (content: string): number => {\n  if (content === \"\") return 0\n  const parts = content.split(\"\\n\")\n  return parts[parts.length - 1] === \"\" ? parts.length - 1 : parts.length\n}\n\n/**\n * Codex `format_exec_output_for_model`: exit code, wall time, optional line\n * count disclosure, then the (possibly middle-truncated) output.\n *\n * @since 1.0.0\n * @private\n */\nexport const formatExecOutputForModel = (options: {\n  readonly output: string\n  readonly exitCode: number\n  readonly durationSeconds: number\n  readonly maxOutputTokens: number\n  readonly timedOutAfterMs?: number | undefined\n}): string => {\n  const content = options.timedOutAfterMs === undefined\n    ? options.output\n    : `command timed out after ${options.timedOutAfterMs} milliseconds\\n${options.output}`\n  const durationSeconds = Math.round(options.durationSeconds * 10) / 10\n  const totalLines = countLines(content)\n  const formatted = truncateMiddleWithTokenBudget(content, options.maxOutputTokens).text\n  const sections = [\n    `Exit code: ${options.exitCode}`,\n    `Wall time: ${durationSeconds} seconds`\n  ]\n  if (totalLines !== countLines(formatted)) sections.push(`Total output lines: ${totalLines}`)\n  sections.push(\"Output:\")\n  sections.push(formatted)\n  return sections.join(\"\\n\")\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Shared declaration helpers for the standard flows.
+ *
+ * @since 1.0.0
+ */
+import type * as Capability from "@smthrs/capability/Capability";
+import * as Effects from "@smthrs/core/Effects";
+/**
+ * Options accepted by {@link envelope}.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface EnvelopeOptions {
+    readonly tier: "sealed" | "compensable" | "irreversible";
+    readonly mode: "hermetic" | "expected";
+    readonly reads: Iterable<string>;
+    readonly writes: Iterable<string>;
+}
+/**
+ * Builds a deterministic effect declaration for a standard flow.
+ *
+ * Every standard flow serializes on conflict: the library owns no lane
+ * partitioning of its own, so the conservative choice is the safe one.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const envelope: (options: EnvelopeOptions) => Effects.Declaration;
+/**
+ * Formats a capability request as the `action:resource` string carried on a
+ * flow declaration.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const capability: (action: Capability.Action, resource: string) => string;
+/**
+ * The read glob covering everything under one search root.
+ *
+ * `glob` and `grep` narrow their conservative `/**` declaration to the root the
+ * call actually names, and a declaration that disagreed between the two would
+ * make the same search reserve different paths depending on which flow ran it.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const rootSubtree: (root: string) => string;
+//# sourceMappingURL=Declaration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Declaration.d.ts","sourceRoot":"","sources":["../../../src/internal/Declaration.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,KAAK,UAAU,MAAM,+BAA+B,CAAA;AAChE,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAA;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAA;IACxD,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAA;IACtC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IAChC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;CAClC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,eAAe,KAAG,OAAO,CAAC,WAOxD,CAAA;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,UAAU,CAAC,MAAM,EAAE,UAAU,MAAM,KAAG,MAAiC,CAAA;AAE1G;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,MAAiE,CAAA"}

package/dist/cjs/internal/Declaration.js

@@ -0,0 +1,46 @@
+"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 Declaration_exports = {};
+__export(Declaration_exports, {
+  capability: () => capability,
+  envelope: () => envelope,
+  rootSubtree: () => rootSubtree
+});
+module.exports = __toCommonJS(Declaration_exports);
+var Effects = __toESM(require("@smthrs/core/Effects"), 1);
+const envelope = (options) => Effects.make({
+  reads: options.reads,
+  writes: options.writes,
+  mode: options.mode,
+  onConflict: "serialize",
+  tier: options.tier
+});
+const capability = (action, resource) => `${action}:${resource}`;
+const rootSubtree = (root) => root === "/" ? "/**" : `${root.replace(/\/+$/, "")}/**`;
+//# sourceMappingURL=Declaration.js.map

package/dist/cjs/internal/Declaration.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Declaration.ts"],
+  "sourcesContent": ["/**\n * Shared declaration helpers for the standard flows.\n *\n * @since 1.0.0\n */\n\nimport type * as Capability from \"@smthrs/capability/Capability\"\nimport * as Effects from \"@smthrs/core/Effects\"\n\n/**\n * Options accepted by {@link envelope}.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface EnvelopeOptions {\n  readonly tier: \"sealed\" | \"compensable\" | \"irreversible\"\n  readonly mode: \"hermetic\" | \"expected\"\n  readonly reads: Iterable<string>\n  readonly writes: Iterable<string>\n}\n\n/**\n * Builds a deterministic effect declaration for a standard flow.\n *\n * Every standard flow serializes on conflict: the library owns no lane\n * partitioning of its own, so the conservative choice is the safe one.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const envelope = (options: EnvelopeOptions): Effects.Declaration =>\n  Effects.make({\n    reads: options.reads,\n    writes: options.writes,\n    mode: options.mode,\n    onConflict: \"serialize\",\n    tier: options.tier\n  })\n\n/**\n * Formats a capability request as the `action:resource` string carried on a\n * flow declaration.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const capability = (action: Capability.Action, resource: string): string => `${action}:${resource}`\n\n/**\n * The read glob covering everything under one search root.\n *\n * `glob` and `grep` narrow their conservative `/**` declaration to the root the\n * call actually names, and a declaration that disagreed between the two would\n * make the same search reserve different paths depending on which flow ran it.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const rootSubtree = (root: string): string => root === \"/\" ? \"/**\" : `${root.replace(/\\/+$/, \"\")}/**`\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,cAAyB;AAwBlB,MAAM,WAAW,CAAC,YACvB,QAAQ,KAAK;AAAA,EACX,OAAO,QAAQ;AAAA,EACf,QAAQ,QAAQ;AAAA,EAChB,MAAM,QAAQ;AAAA,EACd,YAAY;AAAA,EACZ,MAAM,QAAQ;AAChB,CAAC;AASI,MAAM,aAAa,CAAC,QAA2B,aAA6B,GAAG,MAAM,IAAI,QAAQ;AAYjG,MAAM,cAAc,CAAC,SAAyB,SAAS,MAAM,QAAQ,GAAG,KAAK,QAAQ,QAAQ,EAAE,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,77 @@
+/**
+ * Keeps a bound language server in step with the files the mutation flows
+ * write, and reads back the errors an edit leaves.
+ *
+ * The server is optional: a host that binds no `LanguageServer` edits files
+ * exactly as before, and a server that fails or times out never fails the
+ * write that already happened.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as LanguageServer from "../LanguageServer.ts";
+/**
+ * Most errors attached to one result.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const MAX_ERRORS = 20;
+/**
+ * One error-severity diagnostic, at its 1-based position.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const Problem: Schema.Struct<{
+    readonly line: Schema.Number;
+    readonly character: Schema.Number;
+    readonly message: Schema.String;
+}>;
+/**
+ * A decoded {@link Problem}.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export type Problem = typeof Problem.Type;
+/**
+ * The error-severity items of a document diagnostic report, 1-based.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const errors: (report: unknown) => ReadonlyArray<Problem>;
+/**
+ * Sends a written file's new text to the bound server, if any. Succeeds with
+ * the server that took it.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const sync: (path: string, text: string) => Effect.Effect<LanguageServer.LanguageServer | undefined>;
+/**
+ * Tells the bound server, if any, that a file is gone.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const close: (path: string) => Effect.Effect<void>;
+/**
+ * Tells the bound server, if any, to re-read every file it has open, after
+ * something other than the mutation flows may have changed them.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const refresh: Effect.Effect<void>;
+/**
+ * The errors `server` reports for `path`, or `undefined` when it could not
+ * answer.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const errorsOf: (server: LanguageServer.LanguageServer, path: string) => Effect.Effect<ReadonlyArray<Problem> | undefined>;
+//# sourceMappingURL=Diagnostics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Diagnostics.d.ts","sourceRoot":"","sources":["../../../src/internal/Diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;EAIlB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAOzC;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,QAAQ,OAAO,KAAG,aAAa,CAAC,OAAO,CAe7D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,cAAc,GAAG,SAAS,CAUtG,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAMpD,CAAA;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAKvC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GACnB,QAAQ,cAAc,CAAC,cAAc,EACrC,MAAM,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,SAAS,CAIhD,CAAA"}

package/dist/cjs/internal/Diagnostics.js

@@ -0,0 +1,89 @@
+"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 Diagnostics_exports = {};
+__export(Diagnostics_exports, {
+  MAX_ERRORS: () => MAX_ERRORS,
+  Problem: () => Problem,
+  close: () => close,
+  errors: () => errors,
+  errorsOf: () => errorsOf,
+  refresh: () => refresh,
+  sync: () => sync
+});
+module.exports = __toCommonJS(Diagnostics_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var LanguageServer = __toESM(require("../LanguageServer.js"), 1);
+const MAX_ERRORS = 20;
+const Problem = Schema.Struct({
+  line: Schema.Number.annotate({ description: "1-based line" }),
+  character: Schema.Number.annotate({ description: "1-based character" }),
+  message: Schema.String
+});
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const errors = (report) => {
+  const items = record(report)?.items;
+  if (!Array.isArray(items)) return [];
+  const found = [];
+  for (const item of items) {
+    const diagnostic = record(item);
+    const start = record(record(diagnostic?.range)?.start);
+    if (diagnostic?.severity !== 1 || typeof diagnostic.message !== "string" || typeof start?.line !== "number" || typeof start.character !== "number") continue;
+    found.push({ line: start.line + 1, character: start.character + 1, message: diagnostic.message });
+    if (found.length === MAX_ERRORS) break;
+  }
+  return found;
+};
+const sync = (path, text) => Effect.serviceOption(LanguageServer.LanguageServer).pipe(
+  Effect.flatMap(Option.match({
+    onNone: () => Effect.succeed(void 0),
+    onSome: (server) => server.sync(path, text).pipe(
+      Effect.as(server),
+      Effect.orElseSucceed(() => void 0)
+    )
+  }))
+);
+const close = (path) => Effect.serviceOption(LanguageServer.LanguageServer).pipe(
+  Effect.flatMap(Option.match({
+    onNone: () => Effect.void,
+    onSome: (server) => server.close(path).pipe(Effect.ignore)
+  }))
+);
+const refresh = Effect.serviceOption(LanguageServer.LanguageServer).pipe(
+  Effect.flatMap(Option.match({
+    onNone: () => Effect.void,
+    onSome: (server) => server.refresh.pipe(Effect.ignore)
+  }))
+);
+const errorsOf = (server, path) => server.diagnostics(path).pipe(
+  Effect.map(errors),
+  Effect.orElseSucceed(() => void 0)
+);
+//# sourceMappingURL=Diagnostics.js.map

package/dist/cjs/internal/Diagnostics.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Diagnostics.ts"],
+  "sourcesContent": ["/**\n * Keeps a bound language server in step with the files the mutation flows\n * write, and reads back the errors an edit leaves.\n *\n * The server is optional: a host that binds no `LanguageServer` edits files\n * exactly as before, and a server that fails or times out never fails the\n * write that already happened.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\nimport * as LanguageServer from \"../LanguageServer.ts\"\n\n/**\n * Most errors attached to one result.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const MAX_ERRORS = 20\n\n/**\n * One error-severity diagnostic, at its 1-based position.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const Problem = Schema.Struct({\n  line: Schema.Number.annotate({ description: \"1-based line\" }),\n  character: Schema.Number.annotate({ description: \"1-based character\" }),\n  message: Schema.String\n})\n\n/**\n * A decoded {@link Problem}.\n *\n * @category internal\n * @since 1.0.0\n */\nexport type Problem = typeof Problem.Type\n\nconst record = (value: unknown): Readonly<Record<string, unknown>> | undefined =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n    ? value as Readonly<Record<string, unknown>>\n    : undefined\n\n/**\n * The error-severity items of a document diagnostic report, 1-based.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const errors = (report: unknown): ReadonlyArray<Problem> => {\n  const items = record(report)?.items\n  if (!Array.isArray(items)) return []\n  const found: Array<Problem> = []\n  for (const item of items) {\n    const diagnostic = record(item)\n    const start = record(record(diagnostic?.range)?.start)\n    if (\n      diagnostic?.severity !== 1 || typeof diagnostic.message !== \"string\" ||\n      typeof start?.line !== \"number\" || typeof start.character !== \"number\"\n    ) continue\n    found.push({ line: start.line + 1, character: start.character + 1, message: diagnostic.message })\n    if (found.length === MAX_ERRORS) break\n  }\n  return found\n}\n\n/**\n * Sends a written file's new text to the bound server, if any. Succeeds with\n * the server that took it.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const sync = (path: string, text: string): Effect.Effect<LanguageServer.LanguageServer | undefined> =>\n  Effect.serviceOption(LanguageServer.LanguageServer).pipe(\n    Effect.flatMap(Option.match({\n      onNone: () => Effect.succeed(undefined),\n      onSome: (server) =>\n        server.sync(path, text).pipe(\n          Effect.as(server),\n          Effect.orElseSucceed(() => undefined)\n        )\n    }))\n  )\n\n/**\n * Tells the bound server, if any, that a file is gone.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const close = (path: string): Effect.Effect<void> =>\n  Effect.serviceOption(LanguageServer.LanguageServer).pipe(\n    Effect.flatMap(Option.match({\n      onNone: () => Effect.void,\n      onSome: (server) => server.close(path).pipe(Effect.ignore)\n    }))\n  )\n\n/**\n * Tells the bound server, if any, to re-read every file it has open, after\n * something other than the mutation flows may have changed them.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const refresh: Effect.Effect<void> = Effect.serviceOption(LanguageServer.LanguageServer).pipe(\n  Effect.flatMap(Option.match({\n    onNone: () => Effect.void,\n    onSome: (server) => server.refresh.pipe(Effect.ignore)\n  }))\n)\n\n/**\n * The errors `server` reports for `path`, or `undefined` when it could not\n * answer.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const errorsOf = (\n  server: LanguageServer.LanguageServer,\n  path: string\n): Effect.Effect<ReadonlyArray<Problem> | undefined> =>\n  server.diagnostics(path).pipe(\n    Effect.map(errors),\n    Effect.orElseSucceed(() => undefined)\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,aAAwB;AACxB,aAAwB;AACxB,aAAwB;AACxB,qBAAgC;AAQzB,MAAM,aAAa;AAQnB,MAAM,UAAU,OAAO,OAAO;AAAA,EACnC,MAAM,OAAO,OAAO,SAAS,EAAE,aAAa,eAAe,CAAC;AAAA,EAC5D,WAAW,OAAO,OAAO,SAAS,EAAE,aAAa,oBAAoB,CAAC;AAAA,EACtE,SAAS,OAAO;AAClB,CAAC;AAUD,MAAM,SAAS,CAAC,UACd,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D,QACA;AAQC,MAAM,SAAS,CAAC,WAA4C;AACjE,QAAM,QAAQ,OAAO,MAAM,GAAG;AAC9B,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,QAAO,CAAC;AACnC,QAAM,QAAwB,CAAC;AAC/B,aAAW,QAAQ,OAAO;AACxB,UAAM,aAAa,OAAO,IAAI;AAC9B,UAAM,QAAQ,OAAO,OAAO,YAAY,KAAK,GAAG,KAAK;AACrD,QACE,YAAY,aAAa,KAAK,OAAO,WAAW,YAAY,YAC5D,OAAO,OAAO,SAAS,YAAY,OAAO,MAAM,cAAc,SAC9D;AACF,UAAM,KAAK,EAAE,MAAM,MAAM,OAAO,GAAG,WAAW,MAAM,YAAY,GAAG,SAAS,WAAW,QAAQ,CAAC;AAChG,QAAI,MAAM,WAAW,WAAY;AAAA,EACnC;AACA,SAAO;AACT;AASO,MAAM,OAAO,CAAC,MAAc,SACjC,OAAO,cAAc,eAAe,cAAc,EAAE;AAAA,EAClD,OAAO,QAAQ,OAAO,MAAM;AAAA,IAC1B,QAAQ,MAAM,OAAO,QAAQ,MAAS;AAAA,IACtC,QAAQ,CAAC,WACP,OAAO,KAAK,MAAM,IAAI,EAAE;AAAA,MACtB,OAAO,GAAG,MAAM;AAAA,MAChB,OAAO,cAAc,MAAM,MAAS;AAAA,IACtC;AAAA,EACJ,CAAC,CAAC;AACJ;AAQK,MAAM,QAAQ,CAAC,SACpB,OAAO,cAAc,eAAe,cAAc,EAAE;AAAA,EAClD,OAAO,QAAQ,OAAO,MAAM;AAAA,IAC1B,QAAQ,MAAM,OAAO;AAAA,IACrB,QAAQ,CAAC,WAAW,OAAO,MAAM,IAAI,EAAE,KAAK,OAAO,MAAM;AAAA,EAC3D,CAAC,CAAC;AACJ;AASK,MAAM,UAA+B,OAAO,cAAc,eAAe,cAAc,EAAE;AAAA,EAC9F,OAAO,QAAQ,OAAO,MAAM;AAAA,IAC1B,QAAQ,MAAM,OAAO;AAAA,IACrB,QAAQ,CAAC,WAAW,OAAO,QAAQ,KAAK,OAAO,MAAM;AAAA,EACvD,CAAC,CAAC;AACJ;AASO,MAAM,WAAW,CACtB,QACA,SAEA,OAAO,YAAY,IAAI,EAAE;AAAA,EACvB,OAAO,IAAI,MAAM;AAAA,EACjB,OAAO,cAAc,MAAM,MAAS;AACtC;",
+  "names": []
+}

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

@@ -0,0 +1,67 @@
+/**
+ * The hermetic pre-check: a lexical scan of shell text for the paths it names,
+ * and the refusal when one of them falls outside the declared envelope.
+ *
+ * The scan is fail-closed over explicit path tokens and nothing more. It
+ * cannot prove confinement — a shell can name a path no lexer sees, through a
+ * variable, a substitution, or a program that opens a file of its own — so a
+ * kernel or host sandbox must eventually enforce and report the complete read
+ * and write sets.
+ *
+ * It lives beside the flow rather than inside it because it is its own
+ * concept, with its own vocabulary (Access, PathReference) and its own
+ * security history: three independent bypasses, each sufficient on its own to
+ * defeat it, are closed here.
+ *
+ * @since 1.0.0
+ */
+import type * as Path from "@smthrs/kernel/Path";
+import * as StdError from "../StdError.ts";
+/**
+ * The filesystem envelope one invocation declared.
+ *
+ * Structural rather than the hermetic `Bash.Input` itself: the scan needs the
+ * three fields and none of the rest, and depending on the flow module would
+ * make the flow and its pre-check import each other.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Envelope {
+    readonly cwd?: string | undefined;
+    readonly reads: ReadonlyArray<string>;
+    readonly writes: ReadonlyArray<string>;
+}
+/**
+ * How a command touches a path it names.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Access = "read" | "write";
+/**
+ * One path a command names, and how it touches it.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface PathReference {
+    readonly access: Access;
+    readonly value: string;
+}
+/**
+ * Every path token the shell text names, one segment at a time.
+ *
+ * @category pre-check
+ * @since 1.0.0
+ */
+export declare const commandReferences: (path: Path.Path, command: string) => ReadonlyArray<PathReference>;
+/**
+ * The refusal shell text earns by naming a path outside its declared
+ * envelope, or `undefined` when every path it names is declared.
+ *
+ * @category pre-check
+ * @since 1.0.0
+ */
+export declare const outsideEnvelope: (input: Envelope, text: string, path: Path.Path) => StdError.StdError | undefined;
+//# sourceMappingURL=EnvelopePrecheck.d.ts.map

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

@@ -0,0 +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"}

package/dist/cjs/internal/EnvelopePrecheck.js

@@ -0,0 +1,124 @@
+"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 EnvelopePrecheck_exports = {};
+__export(EnvelopePrecheck_exports, {
+  commandReferences: () => commandReferences,
+  outsideEnvelope: () => outsideEnvelope
+});
+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 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 pathValue = (token) => unquote(token).replace(/^\$\(+/, "").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 !== ""
+  );
+  if (hasWrapper) {
+    const mutatingIndex = active.findIndex((token) => {
+      const command2 = path.basename(pathValue(token));
+      return writeCommands.has(command2) || destinationCommands.has(command2);
+    });
+    if (mutatingIndex !== -1) commandIndex = mutatingIndex;
+  }
+  if (commandIndex === -1) return [];
+  const command = path.basename(pathValue(active[commandIndex]));
+  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);
+    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";
+    return { access, value };
+  });
+};
+const commandReferences = (path, command) => {
+  const references = [];
+  let segment = [];
+  for (const token of tokenize(command)) {
+    if (commandSeparators.has(token)) {
+      references.push(...segmentReferences(path, segment));
+      segment = [];
+    } else {
+      segment.push(token);
+    }
+  }
+  references.push(...segmentReferences(path, segment));
+  return references;
+};
+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)),
+  resolvePath(path, cwd, source)
+);
+const outsideEnvelope = (input, text, path) => {
+  const base = path.resolve(".");
+  const cwd = path.resolve(input.cwd ?? ".");
+  if (input.cwd !== void 0 && cwd !== base && !isDeclared(path, cwd, input.reads, cwd)) {
+    return new StdError.StdError({
+      code: "outside_declared_reads",
+      message: `Working directory is outside declared reads: ${cwd}`,
+      path: cwd
+    });
+  }
+  for (const reference of commandReferences(path, text)) {
+    const resolved = resolvePath(path, cwd, reference.value);
+    if (resolved.startsWith("/dev/")) continue;
+    const declared = reference.access === "write" ? input.writes : input.reads;
+    if (!isDeclared(path, cwd, declared, resolved)) {
+      const code = reference.access === "write" ? "outside_declared_writes" : "outside_declared_reads";
+      return new StdError.StdError({
+        code,
+        message: `Command path is outside declared ${reference.access}s: ${resolved}`,
+        path: resolved
+      });
+    }
+  }
+  return void 0;
+};
+//# sourceMappingURL=EnvelopePrecheck.js.map