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

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/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,114 @@
+/**
+ * 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;
+/**
+ * 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;;;;;;;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,82 @@
+"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,
+  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 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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Text.ts"],
+  "sourcesContent": ["/**\n * Shared text paging, numbering, and byte-budget helpers.\n *\n * Every limit here is a display budget, not a policy limit: exceeding one is\n * always disclosed to the model rather than silently applied.\n *\n * @since 1.0.0\n */\n\n/**\n * Default number of lines or entries returned by a paged flow.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const DEFAULT_READ_LIMIT = 2_000\n\n/**\n * Maximum number of directory entries or glob paths returned in one call.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const MAX_ENTRIES = 1_000\n\n/**\n * Maximum number of grep matches returned in one call.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const MAX_GREP_MATCHES = 200\n\n/**\n * Maximum number of Unicode scalar values displayed for a single line.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const MAX_LINE_CHARS = 2_000\n\n/**\n * Maximum UTF-8 byte budget for one rendered text payload.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const MAX_OUTPUT_BYTES = 60_000\n\n/**\n * Maximum UTF-8 byte budget captured per shell output stream.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const MAX_SHELL_OUTPUT_BYTES = 30_000\n\n/**\n * A byte-budgeted rendering of a text value.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Truncation {\n  readonly text: string\n  readonly truncated: boolean\n  readonly keptBytes: number\n  readonly droppedBytes: number\n}\n\n/**\n * One page of source lines.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Page {\n  readonly lines: ReadonlyArray<string>\n  readonly startLine: number\n  readonly endLine: number\n  readonly totalLines: number\n}\n\nconst encoder = new TextEncoder()\nconst fatalDecoder = new TextDecoder(\"utf-8\", { fatal: true })\n\n/**\n * Trims a string to a UTF-8 byte budget without splitting a code point.\n *\n * `keep: \"head\"` retains the beginning of the value; `keep: \"tail\"` retains\n * the end, which is what shell output needs because the interesting part of an\n * overflowing stream is almost always its last lines.\n *\n * @category rendering\n * @since 1.0.0\n */\nexport const truncateBytes = (\n  text: string,\n  maxBytes: number,\n  options: { readonly keep: \"head\" | \"tail\" }\n): Truncation => {\n  const bytes = encoder.encode(text)\n  if (bytes.byteLength <= maxBytes) {\n    return { text, truncated: false, keptBytes: bytes.byteLength, droppedBytes: 0 }\n  }\n  let start = options.keep === \"head\" ? 0 : bytes.byteLength - maxBytes\n  let end = options.keep === \"head\" ? maxBytes : bytes.byteLength\n  // TextEncoder produces valid UTF-8. Moving a cut inward reaches a scalar\n  // boundary after at most three continuation bytes, so decoding must succeed.\n  while (true) {\n    try {\n      const decoded = fatalDecoder.decode(bytes.subarray(start, end))\n      const keptBytes = end - start\n      return {\n        text: decoded,\n        truncated: true,\n        keptBytes,\n        droppedBytes: bytes.byteLength - keptBytes\n      }\n    } catch {\n      if (options.keep === \"head\") end--\n      else start++\n    }\n  }\n}\n\n/**\n * Splits on LF without counting a terminal LF as a line.\n * Carriage returns remain part of each line, including the CR in CRLF, so\n * joining a page with LF preserves its bytes except for the final LF.\n *\n * @category parsing\n * @since 1.0.0\n */\nexport const sourceLines = (text: string): ReadonlyArray<string> => {\n  const lines = text.length === 0 ? [] : text.split(\"\\n\")\n  if (text.endsWith(\"\\n\")) lines.pop()\n  return lines\n}\n\n/**\n * Selects a 1-based page of lines from a text value.\n *\n * @category paging\n * @since 1.0.0\n */\nexport const slice = (\n  text: string,\n  options: { readonly offset: number; readonly limit: number }\n): Page => {\n  const lines = sourceLines(text)\n  const totalLines = lines.length\n  const startLine = Math.max(1, options.offset)\n  const endLine = Math.min(totalLines, startLine + Math.max(0, options.limit) - 1)\n  return {\n    lines: lines.slice(startLine - 1, endLine),\n    startLine,\n    endLine,\n    totalLines\n  }\n}\n\n/**\n * Renders the disclosure appended whenever output was capped.\n *\n * @category rendering\n * @since 1.0.0\n */\nexport const notice = (unit: string, shown: number, total: number): string =>\n  `Showing ${shown} of ${total} ${unit}; output was truncated.`\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,MAAM,qBAAqB;AAQ3B,MAAM,cAAc;AAQpB,MAAM,mBAAmB;AAQzB,MAAM,iBAAiB;AAQvB,MAAM,mBAAmB;AAQzB,MAAM,yBAAyB;AA4BtC,MAAM,UAAU,IAAI,YAAY;AAChC,MAAM,eAAe,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC;AAYtD,MAAM,gBAAgB,CAC3B,MACA,UACA,YACe;AACf,QAAM,QAAQ,QAAQ,OAAO,IAAI;AACjC,MAAI,MAAM,cAAc,UAAU;AAChC,WAAO,EAAE,MAAM,WAAW,OAAO,WAAW,MAAM,YAAY,cAAc,EAAE;AAAA,EAChF;AACA,MAAI,QAAQ,QAAQ,SAAS,SAAS,IAAI,MAAM,aAAa;AAC7D,MAAI,MAAM,QAAQ,SAAS,SAAS,WAAW,MAAM;AAGrD,SAAO,MAAM;AACX,QAAI;AACF,YAAM,UAAU,aAAa,OAAO,MAAM,SAAS,OAAO,GAAG,CAAC;AAC9D,YAAM,YAAY,MAAM;AACxB,aAAO;AAAA,QACL,MAAM;AAAA,QACN,WAAW;AAAA,QACX;AAAA,QACA,cAAc,MAAM,aAAa;AAAA,MACnC;AAAA,IACF,QAAQ;AACN,UAAI,QAAQ,SAAS,OAAQ;AAAA,UACxB;AAAA,IACP;AAAA,EACF;AACF;AAUO,MAAM,cAAc,CAAC,SAAwC;AAClE,QAAM,QAAQ,KAAK,WAAW,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI;AACtD,MAAI,KAAK,SAAS,IAAI,EAAG,OAAM,IAAI;AACnC,SAAO;AACT;AAQO,MAAM,QAAQ,CACnB,MACA,YACS;AACT,QAAM,QAAQ,YAAY,IAAI;AAC9B,QAAM,aAAa,MAAM;AACzB,QAAM,YAAY,KAAK,IAAI,GAAG,QAAQ,MAAM;AAC5C,QAAM,UAAU,KAAK,IAAI,YAAY,YAAY,KAAK,IAAI,GAAG,QAAQ,KAAK,IAAI,CAAC;AAC/E,SAAO;AAAA,IACL,OAAO,MAAM,MAAM,YAAY,GAAG,OAAO;AAAA,IACzC;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAQO,MAAM,SAAS,CAAC,MAAc,OAAe,UAClD,WAAW,KAAK,OAAO,KAAK,IAAI,IAAI;",
+  "names": []
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Shared validation for outbound HTTP URLs.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Parses an HTTP or HTTPS URL without admitting credentials or hostless URLs.
+ *
+ * @category parsing
+ * @since 1.0.0
+ */
+export declare const parseHttpUrl: (value: string, base?: URL) => URL | undefined;
+//# sourceMappingURL=Url.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Url.d.ts","sourceRoot":"","sources":["../../../src/internal/Url.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,OAAO,GAAG,KAAG,GAAG,GAAG,SAU9D,CAAA"}

package/dist/cjs/internal/Url.js

@@ -0,0 +1,35 @@
+"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 Url_exports = {};
+__export(Url_exports, {
+  parseHttpUrl: () => parseHttpUrl
+});
+module.exports = __toCommonJS(Url_exports);
+const parseHttpUrl = (value, base) => {
+  if (value.trim() === "") return void 0;
+  try {
+    const url = base === void 0 ? new URL(value) : new URL(value, base);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    if (url.hostname === "" || url.username !== "" || url.password !== "") return void 0;
+    return url;
+  } catch {
+    return void 0;
+  }
+};
+//# sourceMappingURL=Url.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Url.ts"],
+  "sourcesContent": ["/**\n * Shared validation for outbound HTTP URLs.\n *\n * @since 1.0.0\n */\n\n/**\n * Parses an HTTP or HTTPS URL without admitting credentials or hostless URLs.\n *\n * @category parsing\n * @since 1.0.0\n */\nexport const parseHttpUrl = (value: string, base?: URL): URL | undefined => {\n  if (value.trim() === \"\") return undefined\n  try {\n    const url = base === undefined ? new URL(value) : new URL(value, base)\n    if (url.protocol !== \"http:\" && url.protocol !== \"https:\") return undefined\n    if (url.hostname === \"\" || url.username !== \"\" || url.password !== \"\") return undefined\n    return url\n  } catch {\n    return undefined\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYO,MAAM,eAAe,CAAC,OAAe,SAAgC;AAC1E,MAAI,MAAM,KAAK,MAAM,GAAI,QAAO;AAChC,MAAI;AACF,UAAM,MAAM,SAAS,SAAY,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,OAAO,IAAI;AACrE,QAAI,IAAI,aAAa,WAAW,IAAI,aAAa,SAAU,QAAO;AAClE,QAAI,IAAI,aAAa,MAAM,IAAI,aAAa,MAAM,IAAI,aAAa,GAAI,QAAO;AAC9E,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,72 @@
+/**
+ * The directory names a repository walk never descends into.
+ *
+ * `grep` and `glob` walk with the kernel filesystem, and every entry costs a
+ * guarded stat. A walk rooted at "." that descends into `.git` visits tens of
+ * thousands of object files no search wants: one such `grep` held a benchmark
+ * frame for its entire fifteen-minute ceiling. The skip set is the same
+ * convention ripgrep ships — version control, dependency trees, and caches —
+ * and an explicit root inside a skipped directory still walks, because
+ * skipping applies to descent, never to what the caller named.
+ *
+ * @since 1.0.0
+ */
+import type * as Path from "@smthrs/kernel/Path";
+import { Effect } from "effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as StdError from "../StdError.ts";
+/**
+ * Directory basenames excluded from recursive descent.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const skippedDirectories: ReadonlySet<string>;
+/**
+ * Separates pattern path segments with slashes while preserving POSIX filenames.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const relativeForPattern: (path: Path.Path, from: string, to: string) => string;
+/**
+ * Answers whether each path is a symbolic link, which neither peer follows.
+ *
+ * `FileSystem.stat` resolves links, so the only probe available is `readLink`,
+ * and every probe is one more call in a loop that already makes one per entry.
+ * The walk therefore probes directories, where following a link would duplicate
+ * a subtree or loop forever, and the callers probe the far smaller set of files
+ * they are about to report — batched, never one at a time.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const symbolicLinks: (fileSystem: FileSystem.FileSystem, candidates: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<boolean>>;
+/**
+ * One walk: admitted files, explicit-root status, and ignore exclusions.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export interface Walked {
+    readonly ignored: boolean;
+    readonly explicitFile: boolean;
+    readonly files: ReadonlyArray<string>;
+}
+/**
+ * Lists the files a search under `root` reaches.
+ *
+ * Only the root the caller named is allowed to fail the walk. Every entry
+ * below it that the process cannot inspect — a dangling symlink, a symlink
+ * loop, a directory it may not list — is skipped and the walk continues, which
+ * is what `rg --no-messages` does with the same tree. Turning one of those into
+ * a typed failure would make a whole repository unsearchable because of one
+ * link, and would answer differently from the native peer. Only .gitignore
+ * files within this root are read; ignored directories are never descended.
+ * `included` narrows the empty-result diagnostic without changing descent.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const files: (fileSystem: FileSystem.FileSystem, path: Path.Path, root: string, hidden: boolean, noIgnore?: boolean, included?: (relative: string, basename: string) => boolean) => Effect.Effect<Walked, StdError.StdError>;
+//# sourceMappingURL=Walk.d.ts.map