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

package/dist/esm/Trials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Trials.js","sourceRoot":"","sources":["../../src/Trials.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repeated-run statistics for live model evaluations.\n *\n * A live case runs `n` times and passes `c` of them. {@link passAtK} is the\n * chance that at least one of `k` runs passes, the capability a best-of-k\n * caller sees; {@link passHatK} is the chance that all `k` pass, the\n * consistency a user sees on every attempt. Both are exact for sampling `k` of\n * the `n` recorded runs without replacement.\n *\n * Every function is pure and throws an `EvalError` with code `invalid_trials`\n * for counts outside the documented bounds.\n *\n * @since 0.1.0\n */\n\nimport { EvalError } from \"./EvalError.ts\"\n\n/**\n * Repeated-run statistics for one case.\n *\n * `rate` equals `passAt1`; `stderr` is the standard error of the pass rate,\n * `sqrt(rate * (1 - rate) / n)`, and 0 for a single run.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Summary {\n  readonly n: number\n  readonly passes: number\n  readonly rate: number\n  readonly passAt1: number\n  readonly passAtK: number\n  readonly passHatK: number\n  readonly stderr: number\n}\n\n/**\n * Repeated-run statistics across cases.\n *\n * `passAt1`, `passAtK`, and `passHatK` are means over cases, and `allPass` is\n * the fraction of cases whose every run passed.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Aggregate {\n  readonly cases: number\n  readonly passAt1: number\n  readonly passAtK: number\n  readonly passHatK: number\n  readonly allPass: number\n  readonly perCase: Readonly<Record<string, Summary>>\n}\n\nconst invalid = (message: string, path: string): EvalError => new EvalError({ code: \"invalid_trials\", message, path })\n\nconst validate = (n: number, c: number, k: number): void => {\n  if (!Number.isInteger(n) || n < 1) throw invalid(`Run count must be a positive integer, received ${n}`, \"n\")\n  if (!Number.isInteger(c) || c < 0 || c > n) {\n    throw invalid(`Pass count must be an integer from 0 to ${n}, received ${c}`, \"c\")\n  }\n  if (!Number.isInteger(k) || k < 1 || k > n) throw invalid(`k must be an integer from 1 to ${n}, received ${k}`, \"k\")\n}\n\n/**\n * The unbiased pass@k estimator, `1 - C(n - c, k) / C(n, k)` (Chen et al.,\n * 2021): the chance that at least one of `k` runs drawn from `n` passes. It is\n * computed as a product, so large `n` neither overflows nor loses precision.\n *\n * Throws `invalid_trials` unless `n`, `c`, and `k` are integers with\n * `0 <= c <= n` and `1 <= k <= n`.\n *\n * @since 0.1.0\n * @category statistics\n */\nexport const passAtK = (n: number, c: number, k: number): number => {\n  validate(n, c, k)\n  if (n - c < k) return 1\n  let fail = 1\n  for (let i = n - c + 1; i <= n; i++) fail *= 1 - k / i\n  return 1 - fail\n}\n\n/**\n * pass^k, `C(c, k) / C(n, k)`: the chance that all `k` runs drawn from `n`\n * without replacement pass, the consistency measure of tau-bench.\n *\n * Throws `invalid_trials` under the same bounds as {@link passAtK}.\n *\n * @since 0.1.0\n * @category statistics\n */\nexport const passHatK = (n: number, c: number, k: number): number => {\n  validate(n, c, k)\n  let all = 1\n  for (let i = 0; i < k; i++) all *= (c - i) / (n - i)\n  return Math.max(0, all)\n}\n\n/**\n * Summarizes one case's run outcomes at `k`.\n *\n * Throws `invalid_trials` for no outcomes or a `k` outside `1..n`.\n *\n * @since 0.1.0\n * @category statistics\n */\nexport const summarize = (outcomes: ReadonlyArray<boolean>, k: number): Summary => {\n  const n = outcomes.length\n  const passes = outcomes.filter(Boolean).length\n  validate(n, passes, k)\n  const rate = passes / n\n  return {\n    n,\n    passes,\n    rate,\n    passAt1: rate,\n    passAtK: passAtK(n, passes, k),\n    passHatK: passHatK(n, passes, k),\n    stderr: n <= 1 ? 0 : Math.sqrt(rate * (1 - rate) / n)\n  }\n}\n\nconst mean = (values: ReadonlyArray<number>): number =>\n  values.length === 0 ? 0 : values.reduce((total, value) => total + value, 0) / values.length\n\n/**\n * Summarizes every case at `k` and averages over cases.\n *\n * A case with fewer than `k` runs is summarized at `k = n`, its own run\n * count, so a short case still contributes rather than failing the whole\n * aggregate. No cases aggregate to zeros. Throws `invalid_trials` for a case\n * with no runs or a `k` that is not a positive integer.\n *\n * @since 0.1.0\n * @category statistics\n */\nexport const aggregate = (cases: Readonly<Record<string, ReadonlyArray<boolean>>>, k: number): Aggregate => {\n  if (!Number.isInteger(k) || k < 1) throw invalid(`k must be a positive integer, received ${k}`, \"k\")\n  const perCase: Record<string, Summary> = {}\n  for (const [name, outcomes] of Object.entries(cases)) {\n    if (outcomes.length === 0) throw invalid(`Case '${name}' has no runs`, `cases['${name}']`)\n    perCase[name] = summarize(outcomes, Math.min(k, outcomes.length))\n  }\n  const summaries = Object.values(perCase)\n  return {\n    cases: summaries.length,\n    passAt1: mean(summaries.map((summary) => summary.passAt1)),\n    passAtK: mean(summaries.map((summary) => summary.passAtK)),\n    passHatK: mean(summaries.map((summary) => summary.passHatK)),\n    allPass: mean(summaries.map((summary) => summary.passes === summary.n ? 1 : 0)),\n    perCase\n  }\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Fixed-suite evaluation tools for flows.
+ *
+ * The pipeline runs in one direction: a {@link Suite} declares fixed cases and
+ * the scorers bound to them, a {@link Runner} executes them through an injected
+ * {@link CaseExecutor} and grades the executions, {@link Baseline} records what
+ * a run scored, {@link Regression} compares the next run with that record,
+ * {@link Report} renders the comparison, and {@link Gate} turns it into a CI
+ * exit code.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Typed evaluation failures and the stable codes a caller branches on.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export * as EvalError from "./EvalError.ts";
+/**
+ * Fixed suite declarations and their JSON Lines fixture format.
+ *
+ * @since 0.1.0
+ * @category suites
+ */
+export * as Suite from "./Suite.ts";
+/**
+ * The injectable boundary that executes one case against a target flow.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export * as CaseExecutor from "./CaseExecutor.ts";
+/**
+ * Deterministic suite execution and bound scorer evaluation.
+ *
+ * @since 0.1.0
+ * @category runners
+ */
+export * as Runner from "./Runner.ts";
+/**
+ * Committed baselines: what a suite used to score.
+ *
+ * @since 0.1.0
+ * @category baselines
+ */
+export * as Baseline from "./Baseline.ts";
+/**
+ * Step-key-aware comparison of a run against a baseline.
+ *
+ * @since 0.1.0
+ * @category regression
+ */
+export * as Regression from "./Regression.ts";
+/**
+ * Canonical JSON and Markdown renderings of a comparison.
+ *
+ * @since 0.1.0
+ * @category reports
+ */
+export * as Report from "./Report.ts";
+/**
+ * Score thresholds and the CI exit grade a comparison earns.
+ *
+ * @since 0.1.0
+ * @category gates
+ */
+export * as Gate from "./Gate.ts";
+/**
+ * Repeated-run statistics for live evaluations: pass@k and pass^k.
+ *
+ * @since 0.1.0
+ * @category statistics
+ */
+export * as Trials from "./Trials.ts";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;GAKG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC;;;;;GAKG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;GAKG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC;;;;;GAKG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;GAKG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA"}

package/dist/esm/index.js

@@ -0,0 +1,76 @@
+/**
+ * Fixed-suite evaluation tools for flows.
+ *
+ * The pipeline runs in one direction: a {@link Suite} declares fixed cases and
+ * the scorers bound to them, a {@link Runner} executes them through an injected
+ * {@link CaseExecutor} and grades the executions, {@link Baseline} records what
+ * a run scored, {@link Regression} compares the next run with that record,
+ * {@link Report} renders the comparison, and {@link Gate} turns it into a CI
+ * exit code.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Typed evaluation failures and the stable codes a caller branches on.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export * as EvalError from "./EvalError.js";
+/**
+ * Fixed suite declarations and their JSON Lines fixture format.
+ *
+ * @since 0.1.0
+ * @category suites
+ */
+export * as Suite from "./Suite.js";
+/**
+ * The injectable boundary that executes one case against a target flow.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export * as CaseExecutor from "./CaseExecutor.js";
+/**
+ * Deterministic suite execution and bound scorer evaluation.
+ *
+ * @since 0.1.0
+ * @category runners
+ */
+export * as Runner from "./Runner.js";
+/**
+ * Committed baselines: what a suite used to score.
+ *
+ * @since 0.1.0
+ * @category baselines
+ */
+export * as Baseline from "./Baseline.js";
+/**
+ * Step-key-aware comparison of a run against a baseline.
+ *
+ * @since 0.1.0
+ * @category regression
+ */
+export * as Regression from "./Regression.js";
+/**
+ * Canonical JSON and Markdown renderings of a comparison.
+ *
+ * @since 0.1.0
+ * @category reports
+ */
+export * as Report from "./Report.js";
+/**
+ * Score thresholds and the CI exit grade a comparison earns.
+ *
+ * @since 0.1.0
+ * @category gates
+ */
+export * as Gate from "./Gate.js";
+/**
+ * Repeated-run statistics for live evaluations: pass@k and pass^k.
+ *
+ * @since 0.1.0
+ * @category statistics
+ */
+export * as Trials from "./Trials.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;GAKG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC;;;;;GAKG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;GAKG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC;;;;;GAKG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;GAKG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA","sourcesContent":["/**\n * Fixed-suite evaluation tools for flows.\n *\n * The pipeline runs in one direction: a {@link Suite} declares fixed cases and\n * the scorers bound to them, a {@link Runner} executes them through an injected\n * {@link CaseExecutor} and grades the executions, {@link Baseline} records what\n * a run scored, {@link Regression} compares the next run with that record,\n * {@link Report} renders the comparison, and {@link Gate} turns it into a CI\n * exit code.\n *\n * @since 0.1.0\n */\n\n/**\n * Typed evaluation failures and the stable codes a caller branches on.\n *\n * @since 0.1.0\n * @category errors\n */\nexport * as EvalError from \"./EvalError.ts\"\n/**\n * Fixed suite declarations and their JSON Lines fixture format.\n *\n * @since 0.1.0\n * @category suites\n */\nexport * as Suite from \"./Suite.ts\"\n/**\n * The injectable boundary that executes one case against a target flow.\n *\n * @since 0.1.0\n * @category services\n */\nexport * as CaseExecutor from \"./CaseExecutor.ts\"\n/**\n * Deterministic suite execution and bound scorer evaluation.\n *\n * @since 0.1.0\n * @category runners\n */\nexport * as Runner from \"./Runner.ts\"\n/**\n * Committed baselines: what a suite used to score.\n *\n * @since 0.1.0\n * @category baselines\n */\nexport * as Baseline from \"./Baseline.ts\"\n/**\n * Step-key-aware comparison of a run against a baseline.\n *\n * @since 0.1.0\n * @category regression\n */\nexport * as Regression from \"./Regression.ts\"\n/**\n * Canonical JSON and Markdown renderings of a comparison.\n *\n * @since 0.1.0\n * @category reports\n */\nexport * as Report from \"./Report.ts\"\n/**\n * Score thresholds and the CI exit grade a comparison earns.\n *\n * @since 0.1.0\n * @category gates\n */\nexport * as Gate from \"./Gate.ts\"\n/**\n * Repeated-run statistics for live evaluations: pass@k and pass^k.\n *\n * @since 0.1.0\n * @category statistics\n */\nexport * as Trials from \"./Trials.ts\"\n"]}

package/dist/esm/internal/CanonicalJson.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The one canonical JSON encoder both serializers use.
+ *
+ * A report embeds the raw output of an arbitrary target flow, so the value
+ * being serialized is not JSON and cannot be assumed to be finite, acyclic, or
+ * even readable. A recursive walker over `JSON.stringify` answered that with a
+ * `RangeError` thrown out of a function typed `string`. This encoder is total
+ * instead: every shape JSON cannot express is replaced by a marker that names
+ * what was there, so a report of a broken run is still a report.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Options accepted by {@link encode}.
+ *
+ * @since 0.1.0
+ * @private
+ */
+interface Options {
+    /** Cap on embedded strings; `undefined` keeps them whole. */
+    readonly maxStringLength?: number | undefined;
+    /** Cap on values visited; defaults to {@link maxNodes}. */
+    readonly maxNodes?: number | undefined;
+    /** Cap on encoded output length; defaults to {@link maxBytes}. */
+    readonly maxBytes?: number | undefined;
+}
+/**
+ * The canonical JSON encoder: its limits, key order, and serializers.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const CanonicalJson: {
+    readonly maxDepth: 64;
+    readonly maxStringLength: 8192;
+    readonly maxNodes: 2000000;
+    readonly maxBytes: 33554432;
+    readonly budgetExceeded: "[budget exceeded]";
+    readonly compareText: (left: string, right: string) => number;
+    readonly encode: (value: unknown, options?: Options) => unknown;
+    readonly stringify: (value: unknown, options?: Options) => string;
+};
+export {};
+//# sourceMappingURL=CanonicalJson.d.ts.map

package/dist/esm/internal/CanonicalJson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanonicalJson.d.ts","sourceRoot":"","sources":["../../../src/internal/CanonicalJson.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAiDH;;;;;GAKG;AACH,UAAU,OAAO;IACf,6DAA6D;IAC7D,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7C,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACvC;AAiJD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;iCAzIC,MAAM,SAAS,MAAM,KAAG,MAAM;6BAqHlC,OAAO,YAAW,OAAO,KAAQ,OAAO;gCAYrC,OAAO,YAAW,OAAO,KAAQ,MAAM;CAiBvD,CAAA"}

package/dist/esm/internal/CanonicalJson.js

@@ -0,0 +1,202 @@
+/**
+ * The one canonical JSON encoder both serializers use.
+ *
+ * A report embeds the raw output of an arbitrary target flow, so the value
+ * being serialized is not JSON and cannot be assumed to be finite, acyclic, or
+ * even readable. A recursive walker over `JSON.stringify` answered that with a
+ * `RangeError` thrown out of a function typed `string`. This encoder is total
+ * instead: every shape JSON cannot express is replaced by a marker that names
+ * what was there, so a report of a broken run is still a report.
+ *
+ * @since 0.1.0
+ */
+/**
+ * The nesting depth beyond which a value is replaced by a marker.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const maxDepth = 64;
+/**
+ * Default cap on an embedded string, in UTF-16 code units.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const maxStringLength = 8192;
+/**
+ * Total number of values one encode may visit.
+ *
+ * The cycle detector forgets a value once it leaves it, which is what keeps a
+ * value referenced twice from being reported as a cycle. The cost is that a
+ * shared acyclic graph is re-expanded at every reference, so `n` nested
+ * two-child wrappers over one shared child expand to `2^n` values while
+ * staying far below {@link maxDepth}. The ceiling is roughly three times what
+ * a suite at its declared case limit produces.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const maxNodes = 2_000_000;
+/**
+ * Approximate cap on the encoded output, in UTF-16 code units.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const maxBytes = 33_554_432;
+/**
+ * Marker left where a total budget ran out.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const budgetExceeded = "[budget exceeded]";
+/**
+ * Orders keys by UTF-16 code unit, never by locale.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const truncate = (value, limit) => limit === undefined || value.length <= limit
+    ? value
+    : `${value.slice(0, limit)}[truncated ${value.length - limit} chars]`;
+const primitive = (value, options) => {
+    if (typeof value === "string")
+        return truncate(value, options.maxStringLength);
+    if (typeof value === "number") {
+        if (Number.isNaN(value))
+            return "[NaN]";
+        if (value === Number.POSITIVE_INFINITY)
+            return "[Infinity]";
+        if (value === Number.NEGATIVE_INFINITY)
+            return "[-Infinity]";
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value === "bigint")
+        return `[bigint ${value}]`;
+    if (typeof value === "function")
+        return "[function]";
+    if (typeof value === "symbol")
+        return "[symbol]";
+    return value;
+};
+const unreadable = (cause) => {
+    try {
+        return `[unreadable: ${String(cause)}]`;
+    }
+    catch {
+        return "[unreadable]";
+    }
+};
+const entriesOf = (value) => Object.keys(value).map((key) => {
+    try {
+        return [key, value[key]];
+    }
+    catch (cause) {
+        return [key, unreadable(cause)];
+    }
+});
+const objectOf = (entries, depth, seen, options, budget) => Object.fromEntries(entries
+    .filter(([, entry]) => entry !== undefined)
+    .sort(([left], [right]) => compareText(left, right))
+    .map(([key, entry]) => {
+    // The key is rendered too, so a wide object of long keys spends the
+    // byte budget even when every value is a marker.
+    budget.bytes -= key.length + 3;
+    return [key, walk(entry, depth + 1, seen, options, budget)];
+}));
+const walk = (value, depth, seen, options, budget) => {
+    if (budget.nodes <= 0 || budget.bytes <= 0)
+        return budgetExceeded;
+    budget.nodes -= 1;
+    if (value === null || typeof value !== "object") {
+        const encoded = primitive(value, options);
+        budget.bytes -= typeof encoded === "string" ? encoded.length + 2 : 8;
+        return encoded;
+    }
+    if (seen.has(value))
+        return "[circular]";
+    if (depth > maxDepth)
+        return "[depth exceeded]";
+    budget.bytes -= 2;
+    try {
+        if (value instanceof Date)
+            return Number.isNaN(value.getTime()) ? "[invalid Date]" : value.toISOString();
+        seen.add(value);
+        try {
+            if (value instanceof Error) {
+                const properties = new Map(entriesOf(value));
+                properties.set("name", String(value.name));
+                properties.set("message", String(value.message));
+                return objectOf([...properties], depth, seen, options, budget);
+            }
+            if (Array.isArray(value))
+                return value.map((entry) => walk(entry, depth + 1, seen, options, budget));
+            if (value instanceof Set)
+                return [...value].map((entry) => walk(entry, depth + 1, seen, options, budget));
+            if (value instanceof Map) {
+                return [...value.entries()]
+                    .map(([key, entry]) => [walk(key, depth + 1, seen, options, budget), walk(entry, depth + 1, seen, options, budget)]);
+            }
+            return objectOf(entriesOf(value), depth, seen, options, budget);
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    catch (cause) {
+        return unreadable(cause);
+    }
+};
+/**
+ * Rewrites a value into a shape `JSON.stringify` renders deterministically.
+ *
+ * Object keys are sorted by code unit, `-0` becomes `0`, and `undefined`
+ * members are dropped. Everything JSON cannot express becomes a bracketed
+ * marker rather than a throw or a silent `null`: `[circular]`,
+ * `[depth exceeded]`, `[NaN]`, `[Infinity]`, `[-Infinity]`, `[bigint n]`,
+ * `[function]`, `[symbol]`, and `[unreadable: …]` when a foreign operation
+ * throws. An `Error` becomes an object containing its own enumerable fields
+ * plus `name` and `message`, so typed error fields survive serialization. A
+ * `Date` becomes its ISO string, a `Set` an array, and a `Map` an array of
+ * key/value pairs.
+ *
+ * Traversal is bounded in total, not only per branch: once {@link maxNodes}
+ * values or {@link maxBytes} output code units are spent, every remaining
+ * value becomes `[budget exceeded]`. The budget is spent in traversal order,
+ * and traversal order is fixed by the key sort, so one value always truncates
+ * at the same place.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const encode = (value, options = {}) => walk(value, 0, new Set(), options, {
+    nodes: options.maxNodes ?? maxNodes,
+    bytes: options.maxBytes ?? maxBytes
+});
+/**
+ * Serializes a value as canonical JSON with a trailing newline.
+ *
+ * @since 0.1.0
+ * @private
+ */
+const stringify = (value, options = {}) => `${JSON.stringify(encode(value, options))}\n`;
+/**
+ * The canonical JSON encoder: its limits, key order, and serializers.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export const CanonicalJson = {
+    maxDepth,
+    maxStringLength,
+    maxNodes,
+    maxBytes,
+    budgetExceeded,
+    compareText,
+    encode,
+    stringify
+};
+//# sourceMappingURL=CanonicalJson.js.map

package/dist/esm/internal/CanonicalJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanonicalJson.js","sourceRoot":"","sources":["../../../src/internal/CanonicalJson.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The one canonical JSON encoder both serializers use.\n *\n * A report embeds the raw output of an arbitrary target flow, so the value\n * being serialized is not JSON and cannot be assumed to be finite, acyclic, or\n * even readable. A recursive walker over `JSON.stringify` answered that with a\n * `RangeError` thrown out of a function typed `string`. This encoder is total\n * instead: every shape JSON cannot express is replaced by a marker that names\n * what was there, so a report of a broken run is still a report.\n *\n * @since 0.1.0\n */\n\n/**\n * The nesting depth beyond which a value is replaced by a marker.\n *\n * @since 0.1.0\n * @private\n */\nconst maxDepth = 64\n\n/**\n * Default cap on an embedded string, in UTF-16 code units.\n *\n * @since 0.1.0\n * @private\n */\nconst maxStringLength = 8192\n\n/**\n * Total number of values one encode may visit.\n *\n * The cycle detector forgets a value once it leaves it, which is what keeps a\n * value referenced twice from being reported as a cycle. The cost is that a\n * shared acyclic graph is re-expanded at every reference, so `n` nested\n * two-child wrappers over one shared child expand to `2^n` values while\n * staying far below {@link maxDepth}. The ceiling is roughly three times what\n * a suite at its declared case limit produces.\n *\n * @since 0.1.0\n * @private\n */\nconst maxNodes = 2_000_000\n\n/**\n * Approximate cap on the encoded output, in UTF-16 code units.\n *\n * @since 0.1.0\n * @private\n */\nconst maxBytes = 33_554_432\n\n/**\n * Marker left where a total budget ran out.\n *\n * @since 0.1.0\n * @private\n */\nconst budgetExceeded = \"[budget exceeded]\"\n\n/**\n * Options accepted by {@link encode}.\n *\n * @since 0.1.0\n * @private\n */\ninterface Options {\n  /** Cap on embedded strings; `undefined` keeps them whole. */\n  readonly maxStringLength?: number | undefined\n  /** Cap on values visited; defaults to {@link maxNodes}. */\n  readonly maxNodes?: number | undefined\n  /** Cap on encoded output length; defaults to {@link maxBytes}. */\n  readonly maxBytes?: number | undefined\n}\n\n/** Remaining total work, decremented in traversal order so truncation is stable. */\ninterface Budget {\n  nodes: number\n  bytes: number\n}\n\n/**\n * Orders keys by UTF-16 code unit, never by locale.\n *\n * @since 0.1.0\n * @private\n */\nconst compareText = (left: string, right: string): number => left < right ? -1 : left > right ? 1 : 0\n\nconst truncate = (value: string, limit: number | undefined): string =>\n  limit === undefined || value.length <= limit\n    ? value\n    : `${value.slice(0, limit)}[truncated ${value.length - limit} chars]`\n\nconst primitive = (value: unknown, options: Options): unknown => {\n  if (typeof value === \"string\") return truncate(value, options.maxStringLength)\n  if (typeof value === \"number\") {\n    if (Number.isNaN(value)) return \"[NaN]\"\n    if (value === Number.POSITIVE_INFINITY) return \"[Infinity]\"\n    if (value === Number.NEGATIVE_INFINITY) return \"[-Infinity]\"\n    return Object.is(value, -0) ? 0 : value\n  }\n  if (typeof value === \"bigint\") return `[bigint ${value}]`\n  if (typeof value === \"function\") return \"[function]\"\n  if (typeof value === \"symbol\") return \"[symbol]\"\n  return value\n}\n\nconst unreadable = (cause: unknown): string => {\n  try {\n    return `[unreadable: ${String(cause)}]`\n  } catch {\n    return \"[unreadable]\"\n  }\n}\n\nconst entriesOf = (value: object): ReadonlyArray<readonly [string, unknown]> =>\n  Object.keys(value).map((key) => {\n    try {\n      return [key, (value as { readonly [key: string]: unknown })[key]] as const\n    } catch (cause) {\n      return [key, unreadable(cause)] as const\n    }\n  })\n\nconst objectOf = (\n  entries: ReadonlyArray<readonly [string, unknown]>,\n  depth: number,\n  seen: Set<object>,\n  options: Options,\n  budget: Budget\n): object =>\n  Object.fromEntries(\n    entries\n      .filter(([, entry]) => entry !== undefined)\n      .sort(([left], [right]) => compareText(left, right))\n      .map(([key, entry]) => {\n        // The key is rendered too, so a wide object of long keys spends the\n        // byte budget even when every value is a marker.\n        budget.bytes -= key.length + 3\n        return [key, walk(entry, depth + 1, seen, options, budget)]\n      })\n  )\n\nconst walk = (value: unknown, depth: number, seen: Set<object>, options: Options, budget: Budget): unknown => {\n  if (budget.nodes <= 0 || budget.bytes <= 0) return budgetExceeded\n  budget.nodes -= 1\n  if (value === null || typeof value !== \"object\") {\n    const encoded = primitive(value, options)\n    budget.bytes -= typeof encoded === \"string\" ? encoded.length + 2 : 8\n    return encoded\n  }\n  if (seen.has(value)) return \"[circular]\"\n  if (depth > maxDepth) return \"[depth exceeded]\"\n  budget.bytes -= 2\n  try {\n    if (value instanceof Date) return Number.isNaN(value.getTime()) ? \"[invalid Date]\" : value.toISOString()\n    seen.add(value)\n    try {\n      if (value instanceof Error) {\n        const properties = new Map(entriesOf(value))\n        properties.set(\"name\", String(value.name))\n        properties.set(\"message\", String(value.message))\n        return objectOf([...properties], depth, seen, options, budget)\n      }\n      if (Array.isArray(value)) return value.map((entry) => walk(entry, depth + 1, seen, options, budget))\n      if (value instanceof Set) return [...value].map((entry) => walk(entry, depth + 1, seen, options, budget))\n      if (value instanceof Map) {\n        return [...value.entries()]\n          .map((\n            [key, entry]\n          ) => [walk(key, depth + 1, seen, options, budget), walk(entry, depth + 1, seen, options, budget)])\n      }\n      return objectOf(entriesOf(value), depth, seen, options, budget)\n    } finally {\n      seen.delete(value)\n    }\n  } catch (cause) {\n    return unreadable(cause)\n  }\n}\n\n/**\n * Rewrites a value into a shape `JSON.stringify` renders deterministically.\n *\n * Object keys are sorted by code unit, `-0` becomes `0`, and `undefined`\n * members are dropped. Everything JSON cannot express becomes a bracketed\n * marker rather than a throw or a silent `null`: `[circular]`,\n * `[depth exceeded]`, `[NaN]`, `[Infinity]`, `[-Infinity]`, `[bigint n]`,\n * `[function]`, `[symbol]`, and `[unreadable: …]` when a foreign operation\n * throws. An `Error` becomes an object containing its own enumerable fields\n * plus `name` and `message`, so typed error fields survive serialization. A\n * `Date` becomes its ISO string, a `Set` an array, and a `Map` an array of\n * key/value pairs.\n *\n * Traversal is bounded in total, not only per branch: once {@link maxNodes}\n * values or {@link maxBytes} output code units are spent, every remaining\n * value becomes `[budget exceeded]`. The budget is spent in traversal order,\n * and traversal order is fixed by the key sort, so one value always truncates\n * at the same place.\n *\n * @since 0.1.0\n * @private\n */\nconst encode = (value: unknown, options: Options = {}): unknown =>\n  walk(value, 0, new Set<object>(), options, {\n    nodes: options.maxNodes ?? maxNodes,\n    bytes: options.maxBytes ?? maxBytes\n  })\n\n/**\n * Serializes a value as canonical JSON with a trailing newline.\n *\n * @since 0.1.0\n * @private\n */\nconst stringify = (value: unknown, options: Options = {}): string => `${JSON.stringify(encode(value, options))}\\n`\n\n/**\n * The canonical JSON encoder: its limits, key order, and serializers.\n *\n * @since 0.1.0\n * @private\n */\nexport const CanonicalJson = {\n  maxDepth,\n  maxStringLength,\n  maxNodes,\n  maxBytes,\n  budgetExceeded,\n  compareText,\n  encode,\n  stringify\n} as const\n"]}

package/dist/esm/internal/controlCharacters.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The one control-character rule every trust boundary in this package shares.
+ *
+ * A control character in a name corrupts a Markdown report and a CI log line:
+ * a newline lets the value print its own line, which on GitHub Actions is a
+ * workflow command the runner executes, an ESC or a C1 CSI (U+009B) sequence
+ * rewrites the visible log, and a Unicode bidirectional control reorders what
+ * a reader sees. Values an author declares (suite and case names, baseline
+ * suites and records) are rejected where they enter the system; values a
+ * target returns at runtime (step keys, failure messages) are flattened
+ * instead, so a broken target stays a readable failure rather than a rejected
+ * run.
+ *
+ * The rule covers C0 controls (U+0000 through U+001F), DEL (U+007F), C1
+ * controls (U+0080 through U+009F), and the bidirectional controls U+061C,
+ * U+200E, U+200F, U+202A through U+202E, and U+2066 through U+2069.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Whether one code point falls under the control-character rule.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const isControlCodePoint: (code: number) => boolean;
+/**
+ * Names the first control character in `value`, or `undefined` when there is
+ * none.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const controlCharacter: (value: string) => string | undefined;
+/**
+ * Replaces every control character with a space, the way a report cell does,
+ * so a hostile string cannot emit its own log line, terminal escape, or
+ * reordered text.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const flattenControlCharacters: (value: string) => string;
+//# sourceMappingURL=controlCharacters.d.ts.map

package/dist/esm/internal/controlCharacters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controlCharacters.d.ts","sourceRoot":"","sources":["../../../src/internal/controlCharacters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,OAOd,CAAA;AAEpC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MAAM,GAAG,SAMzD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,MAAM,KAAG,MAOxD,CAAA"}

package/dist/esm/internal/controlCharacters.js

@@ -0,0 +1,65 @@
+/**
+ * The one control-character rule every trust boundary in this package shares.
+ *
+ * A control character in a name corrupts a Markdown report and a CI log line:
+ * a newline lets the value print its own line, which on GitHub Actions is a
+ * workflow command the runner executes, an ESC or a C1 CSI (U+009B) sequence
+ * rewrites the visible log, and a Unicode bidirectional control reorders what
+ * a reader sees. Values an author declares (suite and case names, baseline
+ * suites and records) are rejected where they enter the system; values a
+ * target returns at runtime (step keys, failure messages) are flattened
+ * instead, so a broken target stays a readable failure rather than a rejected
+ * run.
+ *
+ * The rule covers C0 controls (U+0000 through U+001F), DEL (U+007F), C1
+ * controls (U+0080 through U+009F), and the bidirectional controls U+061C,
+ * U+200E, U+200F, U+202A through U+202E, and U+2066 through U+2069.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Whether one code point falls under the control-character rule.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export const isControlCodePoint = (code) => code < 0x20 ||
+    (code >= 0x7f && code <= 0x9f) ||
+    code === 0x061c ||
+    code === 0x200e ||
+    code === 0x200f ||
+    (code >= 0x202a && code <= 0x202e) ||
+    (code >= 0x2066 && code <= 0x2069);
+/**
+ * Names the first control character in `value`, or `undefined` when there is
+ * none.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export const controlCharacter = (value) => {
+    for (const character of value) {
+        const code = character.codePointAt(0);
+        if (isControlCodePoint(code))
+            return `U+${code.toString(16).toUpperCase().padStart(4, "0")}`;
+    }
+    return undefined;
+};
+/**
+ * Replaces every control character with a space, the way a report cell does,
+ * so a hostile string cannot emit its own log line, terminal escape, or
+ * reordered text.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export const flattenControlCharacters = (value) => {
+    if (controlCharacter(value) === undefined)
+        return value;
+    let flattened = "";
+    for (const character of value) {
+        flattened += isControlCodePoint(character.codePointAt(0)) ? " " : character;
+    }
+    return flattened;
+};
+//# sourceMappingURL=controlCharacters.js.map

package/dist/esm/internal/controlCharacters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controlCharacters.js","sourceRoot":"","sources":["../../../src/internal/controlCharacters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,IAAY,EAAW,EAAE,CAC1D,IAAI,GAAG,IAAI;IACX,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC;IAC9B,IAAI,KAAK,MAAM;IACf,IAAI,KAAK,MAAM;IACf,IAAI,KAAK,MAAM;IACf,CAAC,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC;IAClC,CAAC,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC,CAAA;AAEpC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAsB,EAAE;IACpE,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC,CAAE,CAAA;QACtC,IAAI,kBAAkB,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAA;IAC9F,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,KAAa,EAAU,EAAE;IAChE,IAAI,gBAAgB,CAAC,KAAK,CAAC,KAAK,SAAS;QAAE,OAAO,KAAK,CAAA;IACvD,IAAI,SAAS,GAAG,EAAE,CAAA;IAClB,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;QAC9B,SAAS,IAAI,kBAAkB,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAA;IAC9E,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC,CAAA","sourcesContent":["/**\n * The one control-character rule every trust boundary in this package shares.\n *\n * A control character in a name corrupts a Markdown report and a CI log line:\n * a newline lets the value print its own line, which on GitHub Actions is a\n * workflow command the runner executes, an ESC or a C1 CSI (U+009B) sequence\n * rewrites the visible log, and a Unicode bidirectional control reorders what\n * a reader sees. Values an author declares (suite and case names, baseline\n * suites and records) are rejected where they enter the system; values a\n * target returns at runtime (step keys, failure messages) are flattened\n * instead, so a broken target stays a readable failure rather than a rejected\n * run.\n *\n * The rule covers C0 controls (U+0000 through U+001F), DEL (U+007F), C1\n * controls (U+0080 through U+009F), and the bidirectional controls U+061C,\n * U+200E, U+200F, U+202A through U+202E, and U+2066 through U+2069.\n *\n * @since 0.1.0\n */\n\n/**\n * Whether one code point falls under the control-character rule.\n *\n * @since 0.1.0\n * @private\n */\nexport const isControlCodePoint = (code: number): boolean =>\n  code < 0x20 ||\n  (code >= 0x7f && code <= 0x9f) ||\n  code === 0x061c ||\n  code === 0x200e ||\n  code === 0x200f ||\n  (code >= 0x202a && code <= 0x202e) ||\n  (code >= 0x2066 && code <= 0x2069)\n\n/**\n * Names the first control character in `value`, or `undefined` when there is\n * none.\n *\n * @since 0.1.0\n * @private\n */\nexport const controlCharacter = (value: string): string | undefined => {\n  for (const character of value) {\n    const code = character.codePointAt(0)!\n    if (isControlCodePoint(code)) return `U+${code.toString(16).toUpperCase().padStart(4, \"0\")}`\n  }\n  return undefined\n}\n\n/**\n * Replaces every control character with a space, the way a report cell does,\n * so a hostile string cannot emit its own log line, terminal escape, or\n * reordered text.\n *\n * @since 0.1.0\n * @private\n */\nexport const flattenControlCharacters = (value: string): string => {\n  if (controlCharacter(value) === undefined) return value\n  let flattened = \"\"\n  for (const character of value) {\n    flattened += isControlCodePoint(character.codePointAt(0)!) ? \" \" : character\n  }\n  return flattened\n}\n"]}

package/dist/esm/internal/scorerLabel.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The one scorer label rule every rendering in this package shares.
+ *
+ * A scorer has two identities: `scorer` is the key, a digest of the scorer's
+ * own declaration and the only thing a baseline matches on, and `scorerName`
+ * is the readable name carried beside it. A digest is unreadable in a report
+ * cell, a CI log line, or a diagnostic, so each of them prints the name with
+ * the first eight key characters instead. Without a name there is nothing to
+ * abbreviate the key down to, so the label is the key itself: a truncated
+ * digest and no name would leave a reader nothing to match a baseline record
+ * on. One rule is what keeps a report from naming one scorer two ways, an
+ * inconclusive reason built by the runner and a Missing row built by the
+ * reporter agree.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Renders `name (first 8 of the key)`, or the bare key when the scorer carries
+ * no name.
+ *
+ * Every flow carries a name, so a scorer a run holds always has one. A stored
+ * observation may not: a baseline recorded before a scorer was named, or one
+ * written by another tool, carries the key alone, and it labels as the key
+ * rather than as a blank followed by a digest.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const scorerLabel: (identity: {
+    readonly scorer: string;
+    readonly scorerName?: string | undefined;
+}) => string;
+//# sourceMappingURL=scorerLabel.d.ts.map

package/dist/esm/internal/scorerLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scorerLabel.d.ts","sourceRoot":"","sources":["../../../src/internal/scorerLabel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GACtB,UAAU;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,KAC9E,MAGF,CAAA"}

package/dist/esm/internal/scorerLabel.js

@@ -0,0 +1,33 @@
+/**
+ * The one scorer label rule every rendering in this package shares.
+ *
+ * A scorer has two identities: `scorer` is the key, a digest of the scorer's
+ * own declaration and the only thing a baseline matches on, and `scorerName`
+ * is the readable name carried beside it. A digest is unreadable in a report
+ * cell, a CI log line, or a diagnostic, so each of them prints the name with
+ * the first eight key characters instead. Without a name there is nothing to
+ * abbreviate the key down to, so the label is the key itself: a truncated
+ * digest and no name would leave a reader nothing to match a baseline record
+ * on. One rule is what keeps a report from naming one scorer two ways, an
+ * inconclusive reason built by the runner and a Missing row built by the
+ * reporter agree.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Renders `name (first 8 of the key)`, or the bare key when the scorer carries
+ * no name.
+ *
+ * Every flow carries a name, so a scorer a run holds always has one. A stored
+ * observation may not: a baseline recorded before a scorer was named, or one
+ * written by another tool, carries the key alone, and it labels as the key
+ * rather than as a blank followed by a digest.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export const scorerLabel = (identity) => {
+    const name = identity.scorerName;
+    return name === undefined || name.length === 0 ? identity.scorer : `${name} (${identity.scorer.slice(0, 8)})`;
+};
+//# sourceMappingURL=scorerLabel.js.map