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

package/dist/cjs/internal/Symbols.js

@@ -0,0 +1,59 @@
+"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 Symbols_exports = {};
+__export(Symbols_exports, {
+  enclosing: () => enclosing
+});
+module.exports = __toCommonJS(Symbols_exports);
+const declaration = /^([ \t]*)(?:(?:async|export|default|public|private|protected|internal|static|final|abstract|open|pub(?:\([^)]*\))?|unsafe|const|declare)[ \t]+)*(def|class|function|fn|func|struct|impl|interface|trait|enum|module|namespace|type|sub|method)[ \t]+([A-Za-z_$][A-Za-z0-9_$]*)/;
+const closer = /^[ \t]*[)}\]]/;
+const indentOf = (line) => /^[ \t]*/.exec(line)[0].length;
+const blank = (line) => line.trim() === "";
+const enclosing = (lines, line) => {
+  const index = line - 1;
+  if (index < 0 || index >= lines.length) return void 0;
+  let reference = index;
+  while (reference > 0 && blank(lines[reference])) reference--;
+  const indent = indentOf(lines[reference]);
+  let start = -1;
+  let parsed = null;
+  for (let candidate = index; candidate >= 0; candidate--) {
+    const text = lines[candidate];
+    if (blank(text)) continue;
+    const found = declaration.exec(text);
+    if (found === null) continue;
+    if (candidate !== index && indentOf(text) >= indent) continue;
+    start = candidate;
+    parsed = found;
+    break;
+  }
+  if (parsed === null) return void 0;
+  const opening = indentOf(lines[start]);
+  let end = lines.length - 1;
+  for (let candidate = start + 1; candidate < lines.length; candidate++) {
+    const text = lines[candidate];
+    if (blank(text)) continue;
+    if (indentOf(text) > opening) continue;
+    end = closer.test(text) ? candidate : candidate - 1;
+    break;
+  }
+  while (end > start && blank(lines[end])) end--;
+  return { kind: parsed[2], name: parsed[3], startLine: start + 1, endLine: end + 1 };
+};
+//# sourceMappingURL=Symbols.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Symbols.ts"],
+  "sourcesContent": ["/**\n * The definition a line sits inside, read off the file's own shape.\n *\n * A search hit is a line number, and a line number is not a read window. Agents\n * guess one: `offset: line - 10, limit: 40`, which lands short (astropy-15569\n * missed `get_lookup` by one line and probed the wrong binding) or long (six\n * blind-offset reads on sympy-13878). The enclosing definition is the window the\n * hit actually belongs to, and for indentation- and brace-structured source it\n * is derivable from the text already in hand.\n *\n * This is a heuristic and reports only what it can see plainly: a declaration\n * keyword, a name, and the block that keyword opens. When the shape is not\n * plain \u2014 a match at top level, a language this table does not name, a\n * declaration split across lines \u2014 it answers `undefined` rather than guessing,\n * because a wrong window is worse than none.\n *\n * @since 1.0.0\n */\n\n/**\n * The definition enclosing a line.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Symbol {\n  readonly kind: string\n  readonly name: string\n  readonly startLine: number\n  readonly endLine: number\n}\n\n/**\n * Declaration keywords this heuristic recognises across the languages the\n * standard flows meet. Modifiers before the keyword are skipped, the name after\n * it is captured, and everything else is left alone.\n */\nconst declaration =\n  /^([ \\t]*)(?:(?:async|export|default|public|private|protected|internal|static|final|abstract|open|pub(?:\\([^)]*\\))?|unsafe|const|declare)[ \\t]+)*(def|class|function|fn|func|struct|impl|interface|trait|enum|module|namespace|type|sub|method)[ \\t]+([A-Za-z_$][A-Za-z0-9_$]*)/\n\nconst closer = /^[ \\t]*[)}\\]]/\n\nconst indentOf = (line: string): number => /^[ \\t]*/.exec(line)![0].length\n\nconst blank = (line: string): boolean => line.trim() === \"\"\n\n/**\n * The definition enclosing a 1-based line, or `undefined` when there is none to\n * read plainly.\n *\n * @category navigation\n * @since 1.0.0\n */\nexport const enclosing = (lines: ReadonlyArray<string>, line: number): Symbol | undefined => {\n  const index = line - 1\n  if (index < 0 || index >= lines.length) return undefined\n  // A blank match line has no indentation of its own; the nearest text above it\n  // does, and that is the block the blank line belongs to.\n  let reference = index\n  while (reference > 0 && blank(lines[reference]!)) reference--\n  const indent = indentOf(lines[reference]!)\n  let start = -1\n  let parsed: RegExpExecArray | null = null\n  for (let candidate = index; candidate >= 0; candidate--) {\n    const text = lines[candidate]!\n    if (blank(text)) continue\n    const found = declaration.exec(text)\n    if (found === null) continue\n    if (candidate !== index && indentOf(text) >= indent) continue\n    start = candidate\n    parsed = found\n    break\n  }\n  if (parsed === null) return undefined\n  const opening = indentOf(lines[start]!)\n  let end = lines.length - 1\n  for (let candidate = start + 1; candidate < lines.length; candidate++) {\n    const text = lines[candidate]!\n    if (blank(text)) continue\n    if (indentOf(text) > opening) continue\n    // A brace language closes the block at the declaration's own indentation,\n    // and that closing line is part of the definition rather than what follows.\n    end = closer.test(text) ? candidate : candidate - 1\n    break\n  }\n  while (end > start && blank(lines[end]!)) end--\n  return { kind: parsed[2]!, name: parsed[3]!, startLine: start + 1, endLine: end + 1 }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqCA,MAAM,cACJ;AAEF,MAAM,SAAS;AAEf,MAAM,WAAW,CAAC,SAAyB,UAAU,KAAK,IAAI,EAAG,CAAC,EAAE;AAEpE,MAAM,QAAQ,CAAC,SAA0B,KAAK,KAAK,MAAM;AASlD,MAAM,YAAY,CAAC,OAA8B,SAAqC;AAC3F,QAAM,QAAQ,OAAO;AACrB,MAAI,QAAQ,KAAK,SAAS,MAAM,OAAQ,QAAO;AAG/C,MAAI,YAAY;AAChB,SAAO,YAAY,KAAK,MAAM,MAAM,SAAS,CAAE,EAAG;AAClD,QAAM,SAAS,SAAS,MAAM,SAAS,CAAE;AACzC,MAAI,QAAQ;AACZ,MAAI,SAAiC;AACrC,WAAS,YAAY,OAAO,aAAa,GAAG,aAAa;AACvD,UAAM,OAAO,MAAM,SAAS;AAC5B,QAAI,MAAM,IAAI,EAAG;AACjB,UAAM,QAAQ,YAAY,KAAK,IAAI;AACnC,QAAI,UAAU,KAAM;AACpB,QAAI,cAAc,SAAS,SAAS,IAAI,KAAK,OAAQ;AACrD,YAAQ;AACR,aAAS;AACT;AAAA,EACF;AACA,MAAI,WAAW,KAAM,QAAO;AAC5B,QAAM,UAAU,SAAS,MAAM,KAAK,CAAE;AACtC,MAAI,MAAM,MAAM,SAAS;AACzB,WAAS,YAAY,QAAQ,GAAG,YAAY,MAAM,QAAQ,aAAa;AACrE,UAAM,OAAO,MAAM,SAAS;AAC5B,QAAI,MAAM,IAAI,EAAG;AACjB,QAAI,SAAS,IAAI,IAAI,QAAS;AAG9B,UAAM,OAAO,KAAK,IAAI,IAAI,YAAY,YAAY;AAClD;AAAA,EACF;AACA,SAAO,MAAM,SAAS,MAAM,MAAM,GAAG,CAAE,EAAG;AAC1C,SAAO,EAAE,MAAM,OAAO,CAAC,GAAI,MAAM,OAAO,CAAC,GAAI,WAAW,QAAQ,GAAG,SAAS,MAAM,EAAE;AACtF;",
+  "names": []
+}

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

@@ -0,0 +1,23 @@
+/**
+ * The regular files of a tar stream.
+ *
+ * `RemoteSearch` brings a machine's files back with its own `tar`, because
+ * every image ships one and it frames each file with its name and size. GNU
+ * and BusyBox `tar` write GNU long names, `bsdtar` writes POSIX extended
+ * headers, and `xargs` may start `tar` more than once, so the stream can hold
+ * several archives one after another. This reads all of them.
+ *
+ * @since 1.0.0-rc.8
+ */
+/**
+ * Every regular file the stream holds, by member name, or `undefined` when
+ * the stream is not whole tar archives: a header whose checksum does not
+ * hold, a member cut short, or a last archive with no end. A `tar` that
+ * stopped between two members wrote no end, so its missing files are not
+ * mistaken for files it could not read.
+ *
+ * @private
+ * @since 1.0.0-rc.8
+ */
+export declare const files: (stream: Uint8Array) => ReadonlyMap<string, Uint8Array> | undefined;
+//# sourceMappingURL=Tar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tar.d.ts","sourceRoot":"","sources":["../../../src/internal/Tar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAsCH;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,GAAI,QAAQ,UAAU,KAAG,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAoC5E,CAAA"}

package/dist/cjs/internal/Tar.js

@@ -0,0 +1,86 @@
+"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 Tar_exports = {};
+__export(Tar_exports, {
+  files: () => files
+});
+module.exports = __toCommonJS(Tar_exports);
+const decoder = new TextDecoder();
+const text = (bytes) => {
+  const end = bytes.indexOf(0);
+  return decoder.decode(end === -1 ? bytes : bytes.subarray(0, end));
+};
+const octal = (bytes) => {
+  const digits = text(bytes).trim();
+  return /^[0-7]+$/.test(digits) ? Number.parseInt(digits, 8) : void 0;
+};
+const checksum = (header) => {
+  let sum = 0;
+  for (let index = 0; index < 512; index++) sum += index >= 148 && index < 156 ? 32 : header[index];
+  return sum;
+};
+const paxPath = (data) => {
+  let offset = 0;
+  let path;
+  while (offset < data.length) {
+    const space = data.indexOf(32, offset);
+    const length = space === -1 ? Number.NaN : Number(decoder.decode(data.subarray(offset, space)));
+    if (!Number.isSafeInteger(length) || length <= space - offset || offset + length > data.length) return path;
+    const record = decoder.decode(data.subarray(space + 1, offset + length - 1));
+    if (record.startsWith("path=")) path = record.slice("path=".length);
+    offset += length;
+  }
+  return path;
+};
+const files = (stream) => {
+  const found = /* @__PURE__ */ new Map();
+  let longName;
+  let extended;
+  let ended = true;
+  for (let offset = 0; offset + 512 <= stream.length; ) {
+    const header = stream.subarray(offset, offset + 512);
+    offset += 512;
+    ended = header.every((byte) => byte === 0);
+    if (ended) continue;
+    const size = octal(header.subarray(124, 136));
+    if (size === void 0 || octal(header.subarray(148, 156)) !== checksum(header)) return void 0;
+    if (offset + size > stream.length) return void 0;
+    const data = stream.subarray(offset, offset + size);
+    offset += Math.ceil(size / 512) * 512;
+    const type = String.fromCharCode(header[156]);
+    if (type === "L") {
+      longName = text(data);
+      continue;
+    }
+    if (type === "x") {
+      extended = paxPath(data) ?? extended;
+      continue;
+    }
+    if (type === "K" || type === "g") continue;
+    if (type === "0" || type === "\0" || type === "7") {
+      const prefix = decoder.decode(header.subarray(257, 263)) === "ustar\0" ? text(header.subarray(345, 500)) : "";
+      const short = text(header.subarray(0, 100));
+      found.set(extended ?? longName ?? (prefix === "" ? short : `${prefix}/${short}`), data.slice());
+    }
+    longName = void 0;
+    extended = void 0;
+  }
+  return ended ? found : void 0;
+};
+//# sourceMappingURL=Tar.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Tar.ts"],
+  "sourcesContent": ["/**\n * The regular files of a tar stream.\n *\n * `RemoteSearch` brings a machine's files back with its own `tar`, because\n * every image ships one and it frames each file with its name and size. GNU\n * and BusyBox `tar` write GNU long names, `bsdtar` writes POSIX extended\n * headers, and `xargs` may start `tar` more than once, so the stream can hold\n * several archives one after another. This reads all of them.\n *\n * @since 1.0.0-rc.8\n */\n\nconst decoder = new TextDecoder()\n\n/** Bytes up to the first NUL, as text. */\nconst text = (bytes: Uint8Array): string => {\n  const end = bytes.indexOf(0)\n  return decoder.decode(end === -1 ? bytes : bytes.subarray(0, end))\n}\n\n/** An octal header field, or `undefined` when it holds anything else. */\nconst octal = (bytes: Uint8Array): number | undefined => {\n  const digits = text(bytes).trim()\n  return /^[0-7]+$/.test(digits) ? Number.parseInt(digits, 8) : undefined\n}\n\n/** The header's checksum, computed with the checksum field read as spaces. */\nconst checksum = (header: Uint8Array): number => {\n  let sum = 0\n  for (let index = 0; index < 512; index++) sum += index >= 148 && index < 156 ? 32 : header[index]!\n  return sum\n}\n\n/** The `path` record of a POSIX extended header: `<length> <key>=<value>\\n` records. */\nconst paxPath = (data: Uint8Array): string | undefined => {\n  let offset = 0\n  let path: string | undefined\n  while (offset < data.length) {\n    const space = data.indexOf(32, offset)\n    const length = space === -1 ? Number.NaN : Number(decoder.decode(data.subarray(offset, space)))\n    if (!Number.isSafeInteger(length) || length <= space - offset || offset + length > data.length) return path\n    const record = decoder.decode(data.subarray(space + 1, offset + length - 1))\n    if (record.startsWith(\"path=\")) path = record.slice(\"path=\".length)\n    offset += length\n  }\n  return path\n}\n\n/**\n * Every regular file the stream holds, by member name, or `undefined` when\n * the stream is not whole tar archives: a header whose checksum does not\n * hold, a member cut short, or a last archive with no end. A `tar` that\n * stopped between two members wrote no end, so its missing files are not\n * mistaken for files it could not read.\n *\n * @private\n * @since 1.0.0-rc.8\n */\nexport const files = (stream: Uint8Array): ReadonlyMap<string, Uint8Array> | undefined => {\n  const found = new Map<string, Uint8Array>()\n  let longName: string | undefined\n  let extended: string | undefined\n  let ended = true\n  for (let offset = 0; offset + 512 <= stream.length;) {\n    const header = stream.subarray(offset, offset + 512)\n    offset += 512\n    // Zero blocks end one archive; `xargs` may have started another.\n    ended = header.every((byte) => byte === 0)\n    if (ended) continue\n    const size = octal(header.subarray(124, 136))\n    if (size === undefined || octal(header.subarray(148, 156)) !== checksum(header)) return undefined\n    if (offset + size > stream.length) return undefined\n    const data = stream.subarray(offset, offset + size)\n    offset += Math.ceil(size / 512) * 512\n    const type = String.fromCharCode(header[156]!)\n    if (type === \"L\") {\n      longName = text(data)\n      continue\n    }\n    if (type === \"x\") {\n      extended = paxPath(data) ?? extended\n      continue\n    }\n    // A long link name and a global header describe no member of their own.\n    if (type === \"K\" || type === \"g\") continue\n    if (type === \"0\" || type === \"\\0\" || type === \"7\") {\n      const prefix = decoder.decode(header.subarray(257, 263)) === \"ustar\\0\" ? text(header.subarray(345, 500)) : \"\"\n      const short = text(header.subarray(0, 100))\n      found.set(extended ?? longName ?? (prefix === \"\" ? short : `${prefix}/${short}`), data.slice())\n    }\n    longName = undefined\n    extended = undefined\n  }\n  return ended ? found : undefined\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,MAAM,UAAU,IAAI,YAAY;AAGhC,MAAM,OAAO,CAAC,UAA8B;AAC1C,QAAM,MAAM,MAAM,QAAQ,CAAC;AAC3B,SAAO,QAAQ,OAAO,QAAQ,KAAK,QAAQ,MAAM,SAAS,GAAG,GAAG,CAAC;AACnE;AAGA,MAAM,QAAQ,CAAC,UAA0C;AACvD,QAAM,SAAS,KAAK,KAAK,EAAE,KAAK;AAChC,SAAO,WAAW,KAAK,MAAM,IAAI,OAAO,SAAS,QAAQ,CAAC,IAAI;AAChE;AAGA,MAAM,WAAW,CAAC,WAA+B;AAC/C,MAAI,MAAM;AACV,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAS,QAAO,SAAS,OAAO,QAAQ,MAAM,KAAK,OAAO,KAAK;AAChG,SAAO;AACT;AAGA,MAAM,UAAU,CAAC,SAAyC;AACxD,MAAI,SAAS;AACb,MAAI;AACJ,SAAO,SAAS,KAAK,QAAQ;AAC3B,UAAM,QAAQ,KAAK,QAAQ,IAAI,MAAM;AACrC,UAAM,SAAS,UAAU,KAAK,OAAO,MAAM,OAAO,QAAQ,OAAO,KAAK,SAAS,QAAQ,KAAK,CAAC,CAAC;AAC9F,QAAI,CAAC,OAAO,cAAc,MAAM,KAAK,UAAU,QAAQ,UAAU,SAAS,SAAS,KAAK,OAAQ,QAAO;AACvG,UAAM,SAAS,QAAQ,OAAO,KAAK,SAAS,QAAQ,GAAG,SAAS,SAAS,CAAC,CAAC;AAC3E,QAAI,OAAO,WAAW,OAAO,EAAG,QAAO,OAAO,MAAM,QAAQ,MAAM;AAClE,cAAU;AAAA,EACZ;AACA,SAAO;AACT;AAYO,MAAM,QAAQ,CAAC,WAAoE;AACxF,QAAM,QAAQ,oBAAI,IAAwB;AAC1C,MAAI;AACJ,MAAI;AACJ,MAAI,QAAQ;AACZ,WAAS,SAAS,GAAG,SAAS,OAAO,OAAO,UAAS;AACnD,UAAM,SAAS,OAAO,SAAS,QAAQ,SAAS,GAAG;AACnD,cAAU;AAEV,YAAQ,OAAO,MAAM,CAAC,SAAS,SAAS,CAAC;AACzC,QAAI,MAAO;AACX,UAAM,OAAO,MAAM,OAAO,SAAS,KAAK,GAAG,CAAC;AAC5C,QAAI,SAAS,UAAa,MAAM,OAAO,SAAS,KAAK,GAAG,CAAC,MAAM,SAAS,MAAM,EAAG,QAAO;AACxF,QAAI,SAAS,OAAO,OAAO,OAAQ,QAAO;AAC1C,UAAM,OAAO,OAAO,SAAS,QAAQ,SAAS,IAAI;AAClD,cAAU,KAAK,KAAK,OAAO,GAAG,IAAI;AAClC,UAAM,OAAO,OAAO,aAAa,OAAO,GAAG,CAAE;AAC7C,QAAI,SAAS,KAAK;AAChB,iBAAW,KAAK,IAAI;AACpB;AAAA,IACF;AACA,QAAI,SAAS,KAAK;AAChB,iBAAW,QAAQ,IAAI,KAAK;AAC5B;AAAA,IACF;AAEA,QAAI,SAAS,OAAO,SAAS,IAAK;AAClC,QAAI,SAAS,OAAO,SAAS,QAAQ,SAAS,KAAK;AACjD,YAAM,SAAS,QAAQ,OAAO,OAAO,SAAS,KAAK,GAAG,CAAC,MAAM,YAAY,KAAK,OAAO,SAAS,KAAK,GAAG,CAAC,IAAI;AAC3G,YAAM,QAAQ,KAAK,OAAO,SAAS,GAAG,GAAG,CAAC;AAC1C,YAAM,IAAI,YAAY,aAAa,WAAW,KAAK,QAAQ,GAAG,MAAM,IAAI,KAAK,KAAK,KAAK,MAAM,CAAC;AAAA,IAChG;AACA,eAAW;AACX,eAAW;AAAA,EACb;AACA,SAAO,QAAQ,QAAQ;AACzB;",
+  "names": []
+}

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

@@ -0,0 +1,52 @@
+/**
+ * What a test runner said, read out of what it printed.
+ *
+ * A suite's answer is two facts — how many passed, and which ones failed — and
+ * a runner spends twenty to thirty kilobytes of stdout saying them. Paying a
+ * model to read that is the expensive way to learn a number, and the measured
+ * program shows what it costs: sixteen frames on sphinx-8721 existed because a
+ * pre-existing failure was never isolated, and the failure *names* were in the
+ * output all along.
+ *
+ * The parsers below recognise the report shapes the standard runners print.
+ * Precision is the design constraint, exactly as in `Probe`: a reader claims a
+ * complete report only when the runner printed an authoritative completion
+ * statement and the observed outcomes agree with it. Pytest requires a tally,
+ * TAP requires a plan with every planned outcome, and unittest requires its
+ * `Ran` line plus an `OK` or `FAILED` summary. Incomplete captures still return
+ * the outcomes they contain with `parsed: false`. A wrong failure set is worse
+ * than no failure set, because attribution is built on it.
+ *
+ * @since 1.0.0
+ */
+/**
+ * One run's outcome as this module could read it.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Report {
+    readonly passed: number;
+    readonly failed: ReadonlyArray<string>;
+    readonly reportedFailed: number | undefined;
+    readonly parsed: boolean;
+}
+/**
+ * Reads one run's report, or says plainly that it could not.
+ *
+ * @category parsing
+ * @since 1.0.0
+ */
+export declare const parse: (text: string) => Report;
+/**
+ * How two runs of the same command differ, which is the whole of attribution.
+ *
+ * @category parsing
+ * @since 1.0.0
+ */
+export declare const attribute: (current: Report, base: Report) => {
+    readonly introduced: ReadonlyArray<string>;
+    readonly preexisting: ReadonlyArray<string>;
+    readonly fixed: ReadonlyArray<string>;
+} | undefined;
+//# sourceMappingURL=TestReport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TestReport.d.ts","sourceRoot":"","sources":["../../../src/internal/TestReport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACtC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAiHD;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,MAiBpC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,MAAM,MAAM,KACX;IACD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC1C,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACtC,GAAG,SASH,CAAA"}

package/dist/cjs/internal/TestReport.js

@@ -0,0 +1,131 @@
+"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 TestReport_exports = {};
+__export(TestReport_exports, {
+  attribute: () => attribute,
+  parse: () => parse
+});
+module.exports = __toCommonJS(TestReport_exports);
+const unique = (ids) => [...new Set(ids)];
+const collect = (text, pattern) => {
+  const found = [];
+  for (const match of text.matchAll(pattern)) {
+    found.push(match[1]);
+  }
+  return found;
+};
+const count = (text, pattern) => {
+  const match = pattern.exec(text);
+  return match === null ? void 0 : Number(match[1]);
+};
+const pytest = (text) => {
+  const summaryFailed = collect(text, /^(?:FAILED|ERROR)[ \t]+(.+?)(?:[ \t]+-[ \t]+.*)?$/gm);
+  const outcomes = [...text.matchAll(/^(.+?)[ \t]+(PASSED|FAILED|ERROR)(?:[ \t]+.*)?$/gm)];
+  const verboseFailed = outcomes.flatMap((match) => match[2] === "FAILED" || match[2] === "ERROR" ? [match[1]] : []);
+  const verbosePassed = unique(outcomes.flatMap((match) => match[2] === "PASSED" ? [match[1]] : [])).length;
+  const failed = unique([...summaryFailed, ...verboseFailed]);
+  const lastLine = text.trimEnd().split("\n").at(-1);
+  const summary = /^(?:=+[ \t]*)?(\d+ [a-z]+(?:,[ \t]*\d+ [a-z]+)*) in \d+(?:\.\d+)?s(?: \([^)]*\))?[ \t]*(?:=+)?$/.exec(lastLine)?.[1];
+  const tally = summary === void 0 ? void 0 : count(summary, /\b(\d+) passed\b/);
+  const failures = summary === void 0 ? void 0 : count(summary, /\b(\d+) failed\b/);
+  const errors = summary === void 0 ? void 0 : count(summary, /\b(\d+) errors?\b/);
+  const hasTally = tally !== void 0 || failures !== void 0 || errors !== void 0;
+  const reportedFailed = hasTally ? (failures ?? 0) + (errors ?? 0) : void 0;
+  if (!hasTally && outcomes.length === 0 && summaryFailed.length === 0) return void 0;
+  return {
+    passed: tally ?? verbosePassed,
+    failed,
+    reportedFailed,
+    parsed: hasTally && failed.length === reportedFailed
+  };
+};
+const unittest = (text) => {
+  const ran = count(text, /^Ran (\d+) tests?\b/m);
+  const outcomes = [...text.matchAll(/^(?:FAIL|ERROR|UNEXPECTED SUCCESS):[ \t]+(\S+)[ \t]+\(([^)\s]+)\)/gm)];
+  if (ran === void 0 && outcomes.length === 0) return void 0;
+  const failed = unique(
+    outcomes.map((match) => match[2].endsWith(`.${match[1]}`) ? match[2] : `${match[2]}.${match[1]}`)
+  );
+  const summary = /^(OK|FAILED)(?: \(([^)]*)\))?[ \t]*$/m.exec(text);
+  const counts = /* @__PURE__ */ new Map();
+  let known = summary !== null;
+  for (const entry of summary?.[2]?.split(", ") ?? []) {
+    const match = /^(failures|errors|skipped|expected failures|unexpected successes)=(\d+)$/.exec(entry);
+    if (match === null || counts.has(match[1])) known = false;
+    else counts.set(match[1], Number(match[2]));
+  }
+  const reportedFailed = known ? (counts.get("failures") ?? 0) + (counts.get("errors") ?? 0) + (counts.get("unexpected successes") ?? 0) : void 0;
+  const skipped = counts.get("skipped") ?? 0;
+  const expectedFailures = counts.get("expected failures") ?? 0;
+  const passed = ran === void 0 || reportedFailed === void 0 ? 0 : Math.max(0, ran - reportedFailed - skipped - expectedFailures);
+  return {
+    passed,
+    failed,
+    reportedFailed,
+    parsed: ran !== void 0 && reportedFailed !== void 0 && failed.length === reportedFailed && (summary?.[1] === "OK" ? reportedFailed === 0 : reportedFailed > 0) && passed + failed.length + skipped + expectedFailures === ran
+  };
+};
+const tap = (text) => {
+  const outcomes = [...text.matchAll(/^(not ok|ok)\b[ \t]*\d*[ \t]*-?[ \t]*(.*)$/gm)].map((match) => {
+    const directive = /[ \t]*#[ \t]*(SKIP|TODO)\b.*$/i.exec(match[2]);
+    return {
+      ok: match[1] === "ok",
+      id: match[2].slice(0, directive?.index).trim(),
+      directive: directive === null ? void 0 : directive[1].toUpperCase()
+    };
+  });
+  const failures = outcomes.filter((outcome) => !outcome.ok && outcome.directive === void 0);
+  const failed = unique(failures.flatMap((outcome) => outcome.id === "" ? [] : [outcome.id]));
+  const passed = outcomes.filter((outcome) => outcome.ok && outcome.directive !== "SKIP").length;
+  const planned = count(text, /^1\.\.(\d+)\b/m);
+  if (outcomes.length === 0 && planned === void 0) return void 0;
+  const reportedFailed = failures.length;
+  return {
+    passed,
+    failed,
+    reportedFailed,
+    parsed: planned !== void 0 && outcomes.length === planned && failed.length === reportedFailed
+  };
+};
+const parse = (text) => {
+  const hasTap = /^(?:TAP version \d+|1\.\.\d+|not ok\b|ok\b)/m.test(text);
+  const hasUnittest = /^Ran \d+ tests?\b/m.test(text);
+  const lastLine = text.trimEnd().split("\n").at(-1);
+  const hasPytest = /^(?:=+[ \t]*)?\d+ [a-z]+(?:,[ \t]*\d+ [a-z]+)* in \d+(?:\.\d+)?s(?: \([^)]*\))?[ \t]*(?:=+)?$/.test(lastLine);
+  if ([hasTap, hasUnittest, hasPytest].filter(Boolean).length > 1) {
+    return { passed: 0, failed: [], reportedFailed: void 0, parsed: false };
+  }
+  const readers = hasTap ? [tap] : hasUnittest ? [unittest] : hasPytest ? [pytest] : [unittest, pytest, tap];
+  for (const reader of readers) {
+    const report = reader(text);
+    if (report !== void 0) return report;
+  }
+  return { passed: 0, failed: [], reportedFailed: void 0, parsed: false };
+};
+const attribute = (current, base) => {
+  if (!current.parsed || !base.parsed) return void 0;
+  const before = new Set(base.failed);
+  const now = new Set(current.failed);
+  return {
+    introduced: current.failed.filter((id) => !before.has(id)),
+    preexisting: current.failed.filter((id) => before.has(id)),
+    fixed: base.failed.filter((id) => !now.has(id))
+  };
+};
+//# sourceMappingURL=TestReport.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/TestReport.ts"],
+  "sourcesContent": ["/**\n * What a test runner said, read out of what it printed.\n *\n * A suite's answer is two facts \u2014 how many passed, and which ones failed \u2014 and\n * a runner spends twenty to thirty kilobytes of stdout saying them. Paying a\n * model to read that is the expensive way to learn a number, and the measured\n * program shows what it costs: sixteen frames on sphinx-8721 existed because a\n * pre-existing failure was never isolated, and the failure *names* were in the\n * output all along.\n *\n * The parsers below recognise the report shapes the standard runners print.\n * Precision is the design constraint, exactly as in `Probe`: a reader claims a\n * complete report only when the runner printed an authoritative completion\n * statement and the observed outcomes agree with it. Pytest requires a tally,\n * TAP requires a plan with every planned outcome, and unittest requires its\n * `Ran` line plus an `OK` or `FAILED` summary. Incomplete captures still return\n * the outcomes they contain with `parsed: false`. A wrong failure set is worse\n * than no failure set, because attribution is built on it.\n *\n * @since 1.0.0\n */\n\n/**\n * One run's outcome as this module could read it.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Report {\n  readonly passed: number\n  readonly failed: ReadonlyArray<string>\n  readonly reportedFailed: number | undefined\n  readonly parsed: boolean\n}\n\nconst unique = (ids: ReadonlyArray<string>): ReadonlyArray<string> => [...new Set(ids)]\n\nconst collect = (text: string, pattern: RegExp): ReadonlyArray<string> => {\n  const found: Array<string> = []\n  for (const match of text.matchAll(pattern)) {\n    found.push(match[1]!)\n  }\n  return found\n}\n\nconst count = (text: string, pattern: RegExp): number | undefined => {\n  const match = pattern.exec(text)\n  return match === null ? undefined : Number(match[1])\n}\n\n/**\n * pytest, in every verbosity it is normally run at.\n *\n * The short summary (`-rA`, and the default on failure) prints one\n * `FAILED path::id - reason` line per failure, and the tally line prints the\n * authoritative counts. Verbose outcome lines preserve observations from an\n * incomplete capture but cannot establish that the run completed.\n */\nconst pytest = (text: string): Report | undefined => {\n  const summaryFailed = collect(text, /^(?:FAILED|ERROR)[ \\t]+(.+?)(?:[ \\t]+-[ \\t]+.*)?$/gm)\n  const outcomes = [...text.matchAll(/^(.+?)[ \\t]+(PASSED|FAILED|ERROR)(?:[ \\t]+.*)?$/gm)]\n  const verboseFailed = outcomes.flatMap((match) => match[2] === \"FAILED\" || match[2] === \"ERROR\" ? [match[1]!] : [])\n  const verbosePassed = unique(outcomes.flatMap((match) => match[2] === \"PASSED\" ? [match[1]!] : [])).length\n  const failed = unique([...summaryFailed, ...verboseFailed])\n  // Only a terminal pytest summary can certify completion. Earlier diagnostic\n  // lines (including test stdout) are not runner tallies.\n  const lastLine = text.trimEnd().split(\"\\n\").at(-1)!\n  const summary = /^(?:=+[ \\t]*)?(\\d+ [a-z]+(?:,[ \\t]*\\d+ [a-z]+)*) in \\d+(?:\\.\\d+)?s(?: \\([^)]*\\))?[ \\t]*(?:=+)?$/\n    .exec(lastLine)?.[1]\n  const tally = summary === undefined ? undefined : count(summary, /\\b(\\d+) passed\\b/)\n  const failures = summary === undefined ? undefined : count(summary, /\\b(\\d+) failed\\b/)\n  const errors = summary === undefined ? undefined : count(summary, /\\b(\\d+) errors?\\b/)\n  const hasTally = tally !== undefined || failures !== undefined || errors !== undefined\n  const reportedFailed = hasTally ? (failures ?? 0) + (errors ?? 0) : undefined\n  if (!hasTally && outcomes.length === 0 && summaryFailed.length === 0) return undefined\n  return {\n    passed: tally ?? verbosePassed,\n    failed,\n    reportedFailed,\n    parsed: hasTally && failed.length === reportedFailed\n  }\n}\n\n/**\n * unittest, whose failures name a method and a class in the opposite order to\n * the dotted id everything else uses.\n */\nconst unittest = (text: string): Report | undefined => {\n  const ran = count(text, /^Ran (\\d+) tests?\\b/m)\n  const outcomes = [...text.matchAll(/^(?:FAIL|ERROR|UNEXPECTED SUCCESS):[ \\t]+(\\S+)[ \\t]+\\(([^)\\s]+)\\)/gm)]\n  if (ran === undefined && outcomes.length === 0) return undefined\n  const failed = unique(\n    outcomes.map((match) => match[2]!.endsWith(`.${match[1]}`) ? match[2]! : `${match[2]}.${match[1]}`)\n  )\n  const summary = /^(OK|FAILED)(?: \\(([^)]*)\\))?[ \\t]*$/m.exec(text)\n  const counts = new Map<string, number>()\n  let known = summary !== null\n  for (const entry of summary?.[2]?.split(\", \") ?? []) {\n    const match = /^(failures|errors|skipped|expected failures|unexpected successes)=(\\d+)$/.exec(entry)\n    if (match === null || counts.has(match[1]!)) known = false\n    else counts.set(match[1]!, Number(match[2]))\n  }\n  const reportedFailed = known\n    ? (counts.get(\"failures\") ?? 0) + (counts.get(\"errors\") ?? 0) + (counts.get(\"unexpected successes\") ?? 0)\n    : undefined\n  const skipped = counts.get(\"skipped\") ?? 0\n  const expectedFailures = counts.get(\"expected failures\") ?? 0\n  const passed = ran === undefined || reportedFailed === undefined\n    ? 0\n    : Math.max(0, ran - reportedFailed - skipped - expectedFailures)\n  return {\n    passed,\n    failed,\n    reportedFailed,\n    parsed: ran !== undefined && reportedFailed !== undefined && failed.length === reportedFailed &&\n      (summary?.[1] === \"OK\" ? reportedFailed === 0 : reportedFailed > 0) &&\n      passed + failed.length + skipped + expectedFailures === ran\n  }\n}\n\n/**\n * TAP, which several ecosystems emit and which names each test on its own line.\n */\nconst tap = (text: string): Report | undefined => {\n  const outcomes = [...text.matchAll(/^(not ok|ok)\\b[ \\t]*\\d*[ \\t]*-?[ \\t]*(.*)$/gm)].map((match) => {\n    const directive = /[ \\t]*#[ \\t]*(SKIP|TODO)\\b.*$/i.exec(match[2]!)\n    return {\n      ok: match[1] === \"ok\",\n      id: match[2]!.slice(0, directive?.index).trim(),\n      directive: directive === null ? undefined : directive[1]!.toUpperCase()\n    }\n  })\n  const failures = outcomes.filter((outcome) => !outcome.ok && outcome.directive === undefined)\n  const failed = unique(failures.flatMap((outcome) => outcome.id === \"\" ? [] : [outcome.id]))\n  const passed = outcomes.filter((outcome) => outcome.ok && outcome.directive !== \"SKIP\").length\n  const planned = count(text, /^1\\.\\.(\\d+)\\b/m)\n  if (outcomes.length === 0 && planned === undefined) return undefined\n  const reportedFailed = failures.length\n  return {\n    passed,\n    failed,\n    reportedFailed,\n    parsed: planned !== undefined && outcomes.length === planned && failed.length === reportedFailed\n  }\n}\n\n/**\n * Reads one run's report, or says plainly that it could not.\n *\n * @category parsing\n * @since 1.0.0\n */\nexport const parse = (text: string): Report => {\n  const hasTap = /^(?:TAP version \\d+|1\\.\\.\\d+|not ok\\b|ok\\b)/m.test(text)\n  const hasUnittest = /^Ran \\d+ tests?\\b/m.test(text)\n  const lastLine = text.trimEnd().split(\"\\n\").at(-1)!\n  const hasPytest = /^(?:=+[ \\t]*)?\\d+ [a-z]+(?:,[ \\t]*\\d+ [a-z]+)* in \\d+(?:\\.\\d+)?s(?: \\([^)]*\\))?[ \\t]*(?:=+)?$/\n    .test(lastLine)\n  // Two runner completion signatures in one capture cannot establish which\n  // protocol owns the outcomes. Never attribute such a report.\n  if ([hasTap, hasUnittest, hasPytest].filter(Boolean).length > 1) {\n    return { passed: 0, failed: [], reportedFailed: undefined, parsed: false }\n  }\n  const readers = hasTap ? [tap] : hasUnittest ? [unittest] : hasPytest ? [pytest] : [unittest, pytest, tap]\n  for (const reader of readers) {\n    const report = reader(text)\n    if (report !== undefined) return report\n  }\n  return { passed: 0, failed: [], reportedFailed: undefined, parsed: false }\n}\n\n/**\n * How two runs of the same command differ, which is the whole of attribution.\n *\n * @category parsing\n * @since 1.0.0\n */\nexport const attribute = (\n  current: Report,\n  base: Report\n): {\n  readonly introduced: ReadonlyArray<string>\n  readonly preexisting: ReadonlyArray<string>\n  readonly fixed: ReadonlyArray<string>\n} | undefined => {\n  if (!current.parsed || !base.parsed) return undefined\n  const before = new Set(base.failed)\n  const now = new Set(current.failed)\n  return {\n    introduced: current.failed.filter((id) => !before.has(id)),\n    preexisting: current.failed.filter((id) => before.has(id)),\n    fixed: base.failed.filter((id) => !now.has(id))\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,125 @@
+/**
+ * Shared text paging, numbering, and byte-budget helpers.
+ *
+ * Every limit here is a display budget, not a policy limit: exceeding one is
+ * always disclosed to the model rather than silently applied.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Default number of lines or entries returned by a paged flow.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const DEFAULT_READ_LIMIT = 2000;
+/**
+ * Maximum number of directory entries or glob paths returned in one call.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const MAX_ENTRIES = 1000;
+/**
+ * Maximum number of grep matches returned in one call.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const MAX_GREP_MATCHES = 200;
+/**
+ * Maximum number of Unicode scalar values displayed for a single line.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const MAX_LINE_CHARS = 2000;
+/**
+ * Maximum UTF-8 byte budget for one rendered text payload.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const MAX_OUTPUT_BYTES = 60000;
+/**
+ * Maximum UTF-8 byte budget captured per shell output stream.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const MAX_SHELL_OUTPUT_BYTES = 30000;
+/**
+ * A byte-budgeted rendering of a text value.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Truncation {
+    readonly text: string;
+    readonly truncated: boolean;
+    readonly keptBytes: number;
+    readonly droppedBytes: number;
+}
+/**
+ * One page of source lines.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Page {
+    readonly lines: ReadonlyArray<string>;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly totalLines: number;
+}
+/**
+ * Trims a string to a UTF-8 byte budget without splitting a code point.
+ *
+ * `keep: "head"` retains the beginning of the value; `keep: "tail"` retains
+ * the end, which is what shell output needs because the interesting part of an
+ * overflowing stream is almost always its last lines.
+ *
+ * @category rendering
+ * @since 1.0.0
+ */
+export declare const truncateBytes: (text: string, maxBytes: number, options: {
+    readonly keep: "head" | "tail";
+}) => Truncation;
+/**
+ * Joins the start and the end of a stream cut in the middle around one line
+ * naming the bytes cut between them.
+ *
+ * The line stands alone, so a start that stops mid-line is ended before it.
+ * Only the line's own newlines are added; `droppedBytes` counts printed bytes.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.5
+ */
+export declare const elideMiddle: (start: string, droppedBytes: number, end: string) => string;
+/**
+ * Splits on LF without counting a terminal LF as a line.
+ * Carriage returns remain part of each line, including the CR in CRLF, so
+ * joining a page with LF preserves its bytes except for the final LF.
+ *
+ * @category parsing
+ * @since 1.0.0
+ */
+export declare const sourceLines: (text: string) => ReadonlyArray<string>;
+/**
+ * Selects a 1-based page of lines from a text value.
+ *
+ * @category paging
+ * @since 1.0.0
+ */
+export declare const slice: (text: string, options: {
+    readonly offset: number;
+    readonly limit: number;
+}) => Page;
+/**
+ * Renders the disclosure appended whenever output was capped.
+ *
+ * @category rendering
+ * @since 1.0.0
+ */
+export declare const notice: (unit: string, shown: number, total: number) => string;
+//# sourceMappingURL=Text.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Text.d.ts","sourceRoot":"","sources":["../../../src/internal/Text.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,OAAQ,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,WAAW,OAAQ,CAAA;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,OAAQ,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,QAAS,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAKD;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,EACZ,UAAU,MAAM,EAChB,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,KAC1C,UAwBF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,cAAc,MAAM,EAAE,KAAK,MAAM,KAAG,MAG1D,CAAA;AAErB;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,aAAa,CAAC,MAAM,CAI9D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAChB,MAAM,MAAM,EACZ,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,KAC3D,IAWF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,MAAM,KAAG,MACL,CAAA"}

package/dist/cjs/internal/Text.js

@@ -0,0 +1,85 @@
+"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 Text_exports = {};
+__export(Text_exports, {
+  DEFAULT_READ_LIMIT: () => DEFAULT_READ_LIMIT,
+  MAX_ENTRIES: () => MAX_ENTRIES,
+  MAX_GREP_MATCHES: () => MAX_GREP_MATCHES,
+  MAX_LINE_CHARS: () => MAX_LINE_CHARS,
+  MAX_OUTPUT_BYTES: () => MAX_OUTPUT_BYTES,
+  MAX_SHELL_OUTPUT_BYTES: () => MAX_SHELL_OUTPUT_BYTES,
+  elideMiddle: () => elideMiddle,
+  notice: () => notice,
+  slice: () => slice,
+  sourceLines: () => sourceLines,
+  truncateBytes: () => truncateBytes
+});
+module.exports = __toCommonJS(Text_exports);
+const DEFAULT_READ_LIMIT = 2e3;
+const MAX_ENTRIES = 1e3;
+const MAX_GREP_MATCHES = 200;
+const MAX_LINE_CHARS = 2e3;
+const MAX_OUTPUT_BYTES = 6e4;
+const MAX_SHELL_OUTPUT_BYTES = 3e4;
+const encoder = new TextEncoder();
+const fatalDecoder = new TextDecoder("utf-8", { fatal: true });
+const truncateBytes = (text, maxBytes, options) => {
+  const bytes = encoder.encode(text);
+  if (bytes.byteLength <= maxBytes) {
+    return { text, truncated: false, keptBytes: bytes.byteLength, droppedBytes: 0 };
+  }
+  let start = options.keep === "head" ? 0 : bytes.byteLength - maxBytes;
+  let end = options.keep === "head" ? maxBytes : bytes.byteLength;
+  while (true) {
+    try {
+      const decoded = fatalDecoder.decode(bytes.subarray(start, end));
+      const keptBytes = end - start;
+      return {
+        text: decoded,
+        truncated: true,
+        keptBytes,
+        droppedBytes: bytes.byteLength - keptBytes
+      };
+    } catch {
+      if (options.keep === "head") end--;
+      else start++;
+    }
+  }
+};
+const elideMiddle = (start, droppedBytes, end) => `${start}${start === "" || start.endsWith("\n") ? "" : "\n"}[${droppedBytes} ${droppedBytes === 1 ? "byte" : "bytes"} omitted]
+${end}`;
+const sourceLines = (text) => {
+  const lines = text.length === 0 ? [] : text.split("\n");
+  if (text.endsWith("\n")) lines.pop();
+  return lines;
+};
+const slice = (text, options) => {
+  const lines = sourceLines(text);
+  const totalLines = lines.length;
+  const startLine = Math.max(1, options.offset);
+  const endLine = Math.min(totalLines, startLine + Math.max(0, options.limit) - 1);
+  return {
+    lines: lines.slice(startLine - 1, endLine),
+    startLine,
+    endLine,
+    totalLines
+  };
+};
+const notice = (unit, shown, total) => `Showing ${shown} of ${total} ${unit}; output was truncated.`;
+//# sourceMappingURL=Text.js.map