doppeldiff 0.1.0 → 0.1.1

package/dist/cli.js

@@ -64,6 +64,10 @@ function num(n3) {
   if (Object.is(n3, -0)) return "-0";
   return String(n3);
 }
+function list(items, f) {
+  if (!abbreviateLists || items.length <= MAX_ITEMS) return items.map(f).join(", ");
+  return `${items.slice(0, SHOWN_ITEMS).map(f).join(", ")}, \u2026 ${items.length - SHOWN_ITEMS} more`;
+}
 function formatValue(v, max = MAX_LEN) {
   const seen = /* @__PURE__ */ new Set();
   const f = (x) => {
@@ -91,12 +95,11 @@ function formatValue(v, max = MAX_LEN) {
     if (seen.has(x)) return "[Circular]";
     seen.add(x);
     try {
-      if (Array.isArray(x)) return `[${x.map(f).join(", ")}]`;
+      if (Array.isArray(x)) return `[${list(x, f)}]`;
       if (x instanceof Date)
         return Number.isNaN(x.getTime()) ? "new Date(NaN)" : `new Date(${JSON.stringify(x.toISOString())})`;
-      if (x instanceof Map)
-        return `new Map([${[...x].map(([k, val]) => `[${f(k)}, ${f(val)}]`).join(", ")}])`;
-      if (x instanceof Set) return `new Set([${[...x].map(f).join(", ")}])`;
+      if (x instanceof Map) return `new Map([${list([...x], ([k, val]) => `[${f(k)}, ${f(val)}]`)}])`;
+      if (x instanceof Set) return `new Set([${list([...x], f)}])`;
       if (x instanceof RegExp) return String(x);
       if (isProtoDescriptor(x)) {
         const { proto, own } = x[PROTO_TAG];
@@ -110,7 +113,7 @@ function formatValue(v, max = MAX_LEN) {
         return `new ${x.constructor.name}([${Array.from(x).join(", ")}])`;
       const entries = Object.entries(x);
       if (entries.length === 0) return "{}";
-      return `{ ${entries.map(([k, val]) => `${key(k)}: ${f(val)}`).join(", ")} }`;
+      return `{ ${list(entries, ([k, val]) => `${key(k)}: ${f(val)}`)} }`;
     } finally {
       seen.delete(x);
     }
@@ -120,7 +123,16 @@ function formatValue(v, max = MAX_LEN) {
 function formatArgs(args, max = MAX_LEN) {
   return clip(args.map((a) => formatValue(a, max)).join(", "), max);
 }
-function formatEnc(e, max = MAX_LEN) {
+function formatEnc(e, max = MAX_LEN, abbreviate = true) {
+  const previous = abbreviateLists;
+  abbreviateLists = abbreviate;
+  try {
+    return formatEncInner(e, max);
+  } finally {
+    abbreviateLists = previous;
+  }
+}
+function formatEncInner(e, max) {
   const f = (x) => {
     switch (x.t) {
       case "undefined":
@@ -138,18 +150,18 @@ function formatEnc(e, max = MAX_LEN) {
       case "symbol":
         return `Symbol(${x.d})`;
       case "array":
-        return `[${x.items.map(f).join(", ")}]`;
+        return `[${list(x.items, f)}]`;
       case "object": {
         const prefix = x.ctor && x.ctor !== "null-prototype" ? `${x.ctor} ` : "";
         if (x.entries.length === 0) return `${prefix}{}`;
-        return `${prefix}{ ${x.entries.map(([k, v]) => `${key(k)}: ${f(v)}`).join(", ")} }`;
+        return `${prefix}{ ${list(x.entries, ([k, v]) => `${key(k)}: ${f(v)}`)} }`;
       }
       case "date":
         return Number.isNaN(x.v) ? "Invalid Date" : new Date(x.v).toISOString();
       case "map":
-        return `Map(${x.entries.length}) { ${x.entries.map(([k, v]) => `${f(k)} => ${f(v)}`).join(", ")} }`;
+        return `Map(${x.entries.length}) { ${list(x.entries, ([k, v]) => `${f(k)} => ${f(v)}`)} }`;
       case "set":
-        return `Set(${x.items.length}) { ${x.items.map(f).join(", ")} }`;
+        return `Set(${x.items.length}) { ${list(x.items, f)} }`;
       case "regexp":
         return `/${x.source}/${x.flags}`;
       case "function":
@@ -157,7 +169,7 @@ function formatEnc(e, max = MAX_LEN) {
       case "error":
         return `${x.ctor}: ${x.message}`;
       case "typed":
-        return `${x.ctor} [${x.items.join(", ")}]`;
+        return `${x.ctor} [${list(x.items, String)}]`;
       case "promise":
         return "Promise";
       case "cycle":
@@ -168,12 +180,12 @@ function formatEnc(e, max = MAX_LEN) {
   };
   return clip(f(e), max);
 }
-function formatOutcome(o, max = MAX_LEN) {
+function formatOutcome(o, max = MAX_LEN, abbreviate = true) {
   switch (o.kind) {
     case "return":
-      return o.async ? `resolves ${formatEnc(o.value, max)}` : formatEnc(o.value, max);
+      return o.async ? `resolves ${formatEnc(o.value, max, abbreviate)}` : formatEnc(o.value, max, abbreviate);
     case "throw": {
-      const e = o.error.t === "error" ? `${o.error.ctor}: ${o.error.message}` : formatEnc(o.error, max);
+      const e = o.error.t === "error" ? `${o.error.ctor}: ${o.error.message}` : formatEnc(o.error, max, abbreviate);
       return clip(`${o.async ? "rejects" : "throws"} ${e}`, max);
     }
     case "timeout":
@@ -216,12 +228,15 @@ function outcomeCategory(o) {
       return "crash";
   }
 }
-var MAX_LEN, IDENT, key;
+var MAX_LEN, MAX_ITEMS, SHOWN_ITEMS, abbreviateLists, IDENT, key;
 var init_format = __esm({
   "src/core/format/format.ts"() {
     "use strict";
     init_tags();
     MAX_LEN = 120;
+    MAX_ITEMS = 10;
+    SHOWN_ITEMS = 6;
+    abbreviateLists = true;
     IDENT = /^[A-Za-z_$][\w$]*$/;
     key = (k) => IDENT.test(k) ? k : JSON.stringify(k);
   }
@@ -955,6 +970,10 @@ var init_model = __esm({
       inputsRun: z.number().int().nonnegative(),
       stoppedBy: z.enum(["runs", "deadline", "failures", "exhausted"]).optional(),
       failures: z.number().int().nonnegative(),
+      /** Timeouts/crashes on edge-case inputs (huge numbers, NaN, …), included in `failures`. */
+      edgeTimeouts: z.number().int().nonnegative().optional(),
+      /** Edge-case inputs skipped after repeated timeouts on edge-case inputs. */
+      skippedEdgeInputs: z.number().int().nonnegative().optional(),
       durationMs: z.number().nonnegative(),
       seed: z.number().int(),
       usage: z.object({ files: z.number().int(), callSites: z.number().int(), values: z.number().int() }).optional(),
@@ -1054,14 +1073,14 @@ function applyRuleLabels(report, forceRefactor = false) {
   report.summary = summarize(report.functions, report.skipped.length, report.summary.durationMs);
   return report;
 }
-function outcomeView(o) {
+function outcomeView(o, abbreviate = true) {
   switch (o.kind) {
     case "return": {
       const code2 = encToCode(o.value);
       return {
         kind: "return",
         async: o.async,
-        display: formatOutcome(o, MAX_DISPLAY),
+        display: formatOutcome(o, MAX_DISPLAY, abbreviate),
         ...code2 !== void 0 && code2.length < 4e3 ? { code: code2 } : {}
       };
     }
@@ -1070,7 +1089,7 @@ function outcomeView(o) {
       return {
         kind: "throw",
         async: o.async,
-        display: formatOutcome(o, MAX_DISPLAY),
+        display: formatOutcome(o, MAX_DISPLAY, abbreviate),
         ...e.t === "error" ? { errorClass: e.ctor.slice(0, 200), message: e.message.slice(0, 4e3) } : {}
       };
     }
@@ -1087,16 +1106,21 @@ function exampleFrom(exportName, w) {
     new: outcomeView(w.head),
     minimal: w.minimal
   };
+  if (ex.old.display === ex.new.display) {
+    ex.old = outcomeView(w.base, false);
+    ex.new = outcomeView(w.head, false);
+  }
   if (w.diff.aspect === "mutation" && (w.base.kind === "return" || w.base.kind === "throw") && (w.head.kind === "return" || w.head.kind === "throw")) {
     const i = Number(w.diff.path[0]);
     const a = w.base.args[i];
     const b = w.head.args[i];
     if (a && b) {
       const newCode = encToCode(b);
+      const full = formatEnc(a, MAX_DISPLAY) === formatEnc(b, MAX_DISPLAY);
       ex.mutation = {
         argIndex: i,
-        old: formatEnc(a, MAX_DISPLAY),
-        new: formatEnc(b, MAX_DISPLAY),
+        old: formatEnc(a, MAX_DISPLAY, !full),
+        new: formatEnc(b, MAX_DISPLAY, !full),
         ...newCode !== void 0 && newCode.length < 4e3 ? { newCode } : {}
       };
     }
@@ -1128,6 +1152,8 @@ function functionReport(f) {
     inputsRun: f.inputsRun,
     ...f.stoppedBy ? { stoppedBy: f.stoppedBy } : {},
     failures: f.failures,
+    ...f.edgeFailures ? { edgeTimeouts: f.edgeFailures } : {},
+    ...f.skippedEdgeInputs ? { skippedEdgeInputs: f.skippedEdgeInputs } : {},
     durationMs: f.durationMs,
     seed: f.seed,
     ...f.usage ? { usage: f.usage } : {},
@@ -1312,6 +1338,18 @@ function render(r, maxExamples, sticky) {
   const edge = r.functions.flatMap(
     (f) => f.behaviors.filter((b) => b.realism === "edge").map((b) => ({ f, b }))
   );
+  const timedOut = r.functions.filter((f) => (f.edgeTimeouts ?? 0) > 0);
+  const timeoutLine = timedOut.length ? `\u23F1\uFE0F Timed out on edge-case inputs (huge numbers, NaN, \u2026); similar inputs were skipped: ${timedOut.map((f) => `${code(f.exportName, 60)} (${n(f.edgeTimeouts ?? 0)})`).join(", ")}.` : "";
+  if (edge.length === 0 && timeoutLine) {
+    lines.push(
+      "",
+      `<details><summary>\u23F1\uFE0F Some edge-case inputs timed out</summary>`,
+      "",
+      timeoutLine,
+      "",
+      "</details>"
+    );
+  }
   if (edge.length > 0) {
     const reasons = [...new Set(edge.map(({ b }) => b.realismNote).filter(Boolean))].slice(0, 4).join(", ");
     const tag = {
@@ -1324,7 +1362,9 @@ function render(r, maxExamples, sticky) {
       "",
       `<details><summary>\u{1F9EA} ${edge.length} behavior change${edge.length === 1 ? "" : "s"} only on edge-case inputs${reasons ? ` (${escapeText(reasons)})` : ""}</summary>`,
       "",
-      edge.map(({ f, b }) => `${tag[b.label] ?? ""}${behaviorBlock(f, b, maxExamples)}`).join("\n\n"),
+      // Compact: one example per edge-case behavior.
+      edge.map(({ f, b }) => `${tag[b.label] ?? ""}${behaviorBlock(f, b, 1)}`).join("\n\n"),
+      ...timeoutLine ? ["", timeoutLine] : [],
       "",
       "</details>"
     );
@@ -1724,7 +1764,7 @@ var init_pool = __esm({
       }
       /** Execute a job; timeouts and crashes become outcomes, and the process is respawned. */
       async run(job) {
-        const { timeoutMs } = this.options;
+        const timeoutMs = Math.round(this.options.timeoutMs * (job.timeoutScale ?? 1));
         const watchdogMs = timeoutMs + Math.max(150, Math.round(timeoutMs * 0.3));
         const guardKey = `${job.moduleId}#${job.exportName}`;
         const outcomes = new Array(job.inputs.length);
@@ -1748,6 +1788,11 @@ var init_pool = __esm({
               if (m.t === "result" && m.reqId === reqId) {
                 outcomes[offset + m.index] = m.outcome;
                 count = m.index + 1;
+                if (m.outcome.kind === "timeout") {
+                  this.guarded.add(guardKey);
+                  finish({ count }, true);
+                  return;
+                }
                 arm();
               } else if (m.t === "done" && m.reqId === reqId) {
                 finish({ count }, false);
@@ -1829,18 +1874,18 @@ var init_pool = __esm({
         return results[0];
       }
       /** Run inputs, spreading them across processes. Outcomes are returned in input order. */
-      run(moduleId, exportName, inputs) {
-        const result = this.lock.then(() => this.runUnlocked(moduleId, exportName, inputs));
+      run(moduleId, exportName, inputs, options = {}) {
+        const result = this.lock.then(() => this.runUnlocked(moduleId, exportName, inputs, options.timeoutScale));
         this.lock = result.catch(() => void 0);
         return result;
       }
-      async runUnlocked(moduleId, exportName, inputs) {
+      async runUnlocked(moduleId, exportName, inputs, timeoutScale) {
         await this.start();
         const chunkSize = Math.max(16, Math.ceil(inputs.length / this.procs.length));
         const chunks = [];
         for (let i = 0; i < inputs.length; i += chunkSize) chunks.push(inputs.slice(i, i + chunkSize));
         const results = await Promise.all(
-          chunks.map((c, i) => this.procs[i].run({ moduleId, exportName, inputs: c }))
+          chunks.map((c, i) => this.procs[i].run({ moduleId, exportName, inputs: c, timeoutScale }))
         );
         return results.flat();
       }
@@ -4200,6 +4245,18 @@ function numberArb(ctx) {
   );
   return weighted(typeDriven, ctx.mined.numbers, ctx);
 }
+function sizeArb(ctx) {
+  const typeDriven = fc2.oneof(
+    { arbitrary: fc2.integer({ min: 0, max: 10 }), weight: 40 },
+    { arbitrary: fc2.integer({ min: 0, max: 100 }), weight: 25 },
+    { arbitrary: fc2.integer({ min: 0, max: 1e3 }), weight: 8 },
+    { arbitrary: fc2.constantFrom(-1, -2, -10), weight: 3 },
+    { arbitrary: fc2.constantFrom(0.5, 1.5, 2.25), weight: 2 },
+    { arbitrary: fc2.constantFrom(...HUGE_SIZES), weight: 1 }
+  );
+  const mined = ctx.mined.numbers.filter((n3) => Number.isInteger(n3) && n3 >= -10 && n3 <= 1e3);
+  return weighted(typeDriven, mined, ctx);
+}
 function regexSamples(arbs) {
   let out = sampleCache.get(arbs);
   if (!out) {
@@ -4325,7 +4382,7 @@ function anythingArb(ctx) {
 function compile(spec, ctx) {
   switch (spec.kind) {
     case "number":
-      return numberArb(ctx);
+      return spec.size ? sizeArb(ctx) : numberArb(ctx);
     case "bigint":
       return fc2.oneof(fc2.bigInt({ min: -1000n, max: 1000n }), fc2.bigInt());
     case "string":
@@ -4458,7 +4515,7 @@ function compileSignature(sig, options = {}) {
   if (!rest) return base;
   return fc2.tuple(base, fc2.array(rest, { maxLength: 4 })).map(([f, r]) => [...f, ...r]);
 }
-var UTF16_EDGES, STRUCTURAL_FRAGMENTS, INTERESTING_CHARS, SPECIAL_DATES, regexCache, sampleCache, TYPED_ARRAYS;
+var UTF16_EDGES, STRUCTURAL_FRAGMENTS, INTERESTING_CHARS, SPECIAL_DATES, HUGE_SIZES, regexCache, sampleCache, TYPED_ARRAYS;
 var init_compile = __esm({
   "src/core/arbitraries/compile.ts"() {
     "use strict";
@@ -4525,6 +4582,7 @@ var init_compile = __esm({
       /* @__PURE__ */ new Date("1999-12-31T23:59:59.000Z"),
       /* @__PURE__ */ new Date(NaN)
     ];
+    HUGE_SIZES = [2 ** 31 - 1, 2 ** 32, Number.MAX_SAFE_INTEGER, 1e15, Infinity, -Infinity, NaN];
     regexCache = /* @__PURE__ */ new WeakMap();
     sampleCache = /* @__PURE__ */ new WeakMap();
     TYPED_ARRAYS = {
@@ -4543,6 +4601,91 @@ var init_compile = __esm({
   }
 });
 
+// src/core/analyze/sizeParams.ts
+import { Node as Node4, SyntaxKind as SyntaxKind4 } from "ts-morph";
+function isLoopCondition(node) {
+  for (let p = node.getParent(); p; p = p.getParent()) {
+    if (Node4.isForStatement(p)) return p.getCondition() !== void 0 && isWithin2(node, p.getCondition());
+    if (Node4.isWhileStatement(p) || Node4.isDoStatement(p)) return isWithin2(node, p.getExpression());
+    if (Node4.isBlock(p) || Node4.isFunctionLikeDeclaration(p)) return false;
+  }
+  return false;
+}
+function isWithin2(node, container) {
+  return node.getPos() >= container.getPos() && node.getEnd() <= container.getEnd();
+}
+function usedAsSize(id) {
+  const parent = id.getParent();
+  if (!parent) return false;
+  if (Node4.isBinaryExpression(parent)) {
+    const op = parent.getOperatorToken().getKind();
+    const comparison = op === SyntaxKind4.LessThanToken || op === SyntaxKind4.LessThanEqualsToken || op === SyntaxKind4.GreaterThanToken || op === SyntaxKind4.GreaterThanEqualsToken;
+    if (comparison && isLoopCondition(parent)) return true;
+  }
+  if (Node4.isElementAccessExpression(parent) && parent.getArgumentExpression() === id) return true;
+  if (Node4.isPropertyAssignment(parent) && parent.getName() === "length" && parent.getInitializer() === id)
+    return true;
+  if (Node4.isShorthandPropertyAssignment(parent) && parent.getName() === "length") return true;
+  if ((Node4.isCallExpression(parent) || Node4.isNewExpression(parent)) && parent.getArguments().includes(id)) {
+    const callee = parent.getExpression();
+    const name = Node4.isPropertyAccessExpression(callee) ? callee.getName() : callee.getText();
+    if (name === "Array" || LENGTH_CALLS.has(name)) return true;
+  }
+  return false;
+}
+function sizeLikeParams(fns) {
+  const out = /* @__PURE__ */ new Set();
+  for (const fn of fns) {
+    if (!(Node4.isFunctionDeclaration(fn) || Node4.isFunctionExpression(fn) || Node4.isArrowFunction(fn)))
+      continue;
+    const params = fn.getParameters().map((p) => p.getNameNode()).filter((n3) => Node4.isIdentifier(n3)).map((n3) => n3.getText());
+    for (const name of params) {
+      if (SIZE_NAME.test(name)) {
+        out.add(name);
+        continue;
+      }
+      const body = fn.getBody();
+      if (!body) continue;
+      const refs = body.getDescendantsOfKind(SyntaxKind4.Identifier).filter((id) => id.getText() === name).filter((id) => {
+        const p = id.getParent();
+        return !(Node4.isPropertyAccessExpression(p) && p.getNameNode() === id);
+      });
+      if (refs.some(usedAsSize)) {
+        out.add(name);
+        continue;
+      }
+      for (const decl of body.getDescendantsOfKind(SyntaxKind4.VariableDeclaration)) {
+        const init = decl.getInitializer();
+        const local = decl.getNameNode();
+        if (!init || !Node4.isIdentifier(local) || !refs.some((r) => isWithin2(r, init))) continue;
+        const localRefs = body.getDescendantsOfKind(SyntaxKind4.Identifier).filter((id) => id.getText() === local.getText() && id !== local);
+        if (localRefs.some(usedAsSize)) {
+          out.add(name);
+          break;
+        }
+      }
+    }
+  }
+  return out;
+}
+var SIZE_NAME, LENGTH_CALLS;
+var init_sizeParams = __esm({
+  "src/core/analyze/sizeParams.ts"() {
+    "use strict";
+    SIZE_NAME = /^(n|k|count|size|length|len|times|limit|index|idx|width|height|depth|pages?|parts|chunks?|rows|cols|columns|steps|retries|attempts|digits|places|precision|decimals|people|items|level|levels)$|(Count|Size|Length|Index|Limit|Width|Height|Depth|Times)$/;
+    LENGTH_CALLS = /* @__PURE__ */ new Set([
+      "repeat",
+      "padStart",
+      "padEnd",
+      "at",
+      "slice",
+      "substring",
+      "substr",
+      "splice"
+    ]);
+  }
+});
+
 // src/core/compare/compare.ts
 function diffEnc(a, b, opts = {}, path = []) {
   if (a.t !== b.t) return path;
@@ -4839,6 +4982,10 @@ import { xoroshiro128plus } from "pure-rand/generator/xoroshiro128plus";
 function biasFor(runIndex) {
   return 2 + Math.floor(Math.log(runIndex + 1) / Math.log(10));
 }
+function witnessCost(input, r) {
+  const out = r ? formatOutcome(r.base, 2e3, false).length + formatOutcome(r.head, 2e3, false).length : 0;
+  return inputComplexity(input) + Math.max(0, out - 40) / 20;
+}
 async function explore(options) {
   const {
     arbitrary,
@@ -4851,6 +4998,8 @@ async function explore(options) {
     shrinkBudget = 500,
     maxWitnesses = 3,
     maxFailures = 20,
+    maxEdgeFailures = 2,
+    maxTimeoutChecks = 12,
     selfCheck = 50,
     humanizeBudget = 150
   } = options;
@@ -4868,7 +5017,13 @@ async function explore(options) {
     return t;
   };
   let outOfDomain = 0;
+  let edgeFailures = 0;
+  let skippedEdgeInputs = 0;
   const wanted = (input) => {
+    if (options.realism && edgeFailures >= maxEdgeFailures && tierOf(input) === 0) {
+      skippedEdgeInputs++;
+      return false;
+    }
     if (!options.inDomain || options.inDomain(input)) return true;
     if (options.strictDomain) return false;
     return outOfDomain++ % 4 === 0;
@@ -4887,8 +5042,30 @@ async function explore(options) {
   let failures = 0;
   let shrinkEvaluations = 0;
   let stoppedBy = "runs";
-  const countFailures = (r) => {
-    if ([r.base, r.head].some((o) => o.kind === "timeout" || o.kind === "crash")) failures++;
+  const countFailures = (input, r) => {
+    if (![r.base, r.head].some((o) => o.kind === "timeout" || o.kind === "crash")) return;
+    failures++;
+    if (options.realism && tierOf(input) === 0) edgeFailures++;
+  };
+  const realisticFailures = () => failures - edgeFailures;
+  let timeoutChecks = 0;
+  const timedOut = (r) => r.base.kind === "timeout" || r.head.kind === "timeout";
+  const confirmTimeouts = async (inputs, results) => {
+    const idx2 = results.map((r, i) => i).filter((i) => timedOut(results[i]) && !(options.realism && tierOf(inputs[i]) === 0)).slice(0, Math.max(0, maxTimeoutChecks - timeoutChecks));
+    if (idx2.length === 0) return;
+    timeoutChecks += idx2.length;
+    const again = await evaluate(
+      idx2.map((i) => inputs[i]),
+      { timeoutScale: 4 }
+    );
+    idx2.forEach((i, j) => {
+      const first2 = results[i];
+      const second = again[j];
+      results[i] = {
+        base: first2.base.kind === "timeout" ? second.base : first2.base,
+        head: first2.head.kind === "timeout" ? second.head : first2.head
+      };
+    });
   };
   const evalCached = async (inputs) => {
     const keys = inputs.map(stableKey);
@@ -4902,9 +5079,10 @@ async function explore(options) {
     });
     if (missing.length > 0) {
       const results = await evaluate(missing);
+      await confirmTimeouts(missing, results);
       results.forEach((r, i) => {
         cache.set(missingKeys[i], r);
-        countFailures(r);
+        countFailures(missing[i], r);
       });
     }
     return keys.map((k) => cache.get(k));
@@ -4979,12 +5157,14 @@ async function explore(options) {
             flakyClusters: 0,
             stoppedBy: "runs",
             shrinkEvaluations: 0,
-            failures
+            failures,
+            edgeFailures,
+            skippedEdgeInputs
           };
         }
       }
       cache.set(stableKey(inputs[i]), a[i]);
-      countFailures(a[i]);
+      countFailures(inputs[i], a[i]);
       record(first[i], a[i]);
     }
     inputsRun = inputs.length;
@@ -4997,7 +5177,7 @@ async function explore(options) {
       stoppedBy = "deadline";
       break;
     }
-    if (failures >= maxFailures) {
+    if (realisticFailures() >= maxFailures) {
       stoppedBy = "failures";
       break;
     }
@@ -5023,9 +5203,13 @@ async function explore(options) {
     }
     staleBatches = 0;
     const results = await evaluate(batch.map((p) => p.value.value));
+    await confirmTimeouts(
+      batch.map((p) => p.value.value),
+      results
+    );
     results.forEach((r, i) => {
       cache.set(batch[i].key, r);
-      countFailures(r);
+      countFailures(batch[i].value.value, r);
       record(batch[i].value, r);
     });
     inputsRun += batch.length;
@@ -5035,6 +5219,12 @@ async function explore(options) {
   for (const cluster of clusters.values()) {
     let cur = cluster.seed;
     let evals = 0;
+    const w0 = cluster.witnesses[0];
+    if (w0.base.kind === "timeout" || w0.head.kind === "timeout") {
+      cluster.witnesses.length = 1;
+      cluster.witnesses[0].minimal = true;
+      continue;
+    }
     if (exampleValues.has(cur) && !arbitrary.canShrinkWithoutContext(cur.value)) continue;
     let improved = true;
     while (improved && evals < shrinkBudget) {
@@ -5061,7 +5251,7 @@ async function explore(options) {
           break;
         }
       }
-      if (failures >= maxFailures * 2) break;
+      if (realisticFailures() >= maxFailures * 2) break;
     }
     shrinkEvaluations += evals;
     const sameCluster = async (candidates) => {
@@ -5076,7 +5266,9 @@ async function explore(options) {
       finals.set(stableKey(h.input), h.input);
       finals.set(stableKey(start), start);
     }
-    const ranked = [...finals.values()].filter((input) => classify(input, cache.get(stableKey(input)))?.key === cluster.key).sort((a, b) => tierOf(b) - tierOf(a) || inputComplexity(a) - inputComplexity(b)).slice(0, maxWitnesses);
+    const ranked = [...finals.values()].filter((input) => classify(input, cache.get(stableKey(input)))?.key === cluster.key).sort(
+      (a, b) => tierOf(b) - tierOf(a) || witnessCost(a, cache.get(stableKey(a))) - witnessCost(b, cache.get(stableKey(b)))
+    ).slice(0, maxWitnesses);
     cluster.witnesses = ranked.map((input, i) => {
       const r = cache.get(stableKey(input));
       const w = {
@@ -5094,7 +5286,7 @@ async function explore(options) {
     for (const cluster of clusters.values()) {
       for (const w of cluster.witnesses) w.realism ??= options.realism(w.input);
       cluster.witnesses.sort(
-        (a, b) => b.realism.tier - a.realism.tier || inputComplexity(a.input) - inputComplexity(b.input)
+        (a, b) => b.realism.tier - a.realism.tier || witnessCost(a.input, { base: a.base, head: a.head }) - witnessCost(b.input, { base: b.base, head: b.head })
       );
       cluster.witnesses.forEach((w, i) => w.minimal = i === 0);
     }
@@ -5126,7 +5318,9 @@ async function explore(options) {
     flakyClusters,
     stoppedBy,
     shrinkEvaluations,
-    failures
+    failures,
+    edgeFailures,
+    skippedEdgeInputs
   };
 }
 var size;
@@ -5228,6 +5422,11 @@ function printSpec(spec) {
       return spec.kind;
   }
 }
+function markSize(spec) {
+  if (spec.kind === "number") return { kind: "number", size: true };
+  if (spec.kind === "union") return { ...spec, options: spec.options.map(markSize) };
+  return spec;
+}
 var BINARY_CTORS;
 var init_spec = __esm({
   "src/core/types/spec.ts"() {
@@ -5252,7 +5451,7 @@ var init_spec = __esm({
 
 // src/core/types/fromType.ts
 import {
-  Node as Node4,
+  Node as Node5,
   ts as ts4
 } from "ts-morph";
 function typeId(type) {
@@ -5384,7 +5583,7 @@ function objectLike(type, ctx) {
 }
 function isClassInstance(type) {
   const decls = type.getSymbol()?.getDeclarations() ?? [];
-  return decls.some((d) => Node4.isClassDeclaration(d) || Node4.isClassExpression(d));
+  return decls.some((d) => Node5.isClassDeclaration(d) || Node5.isClassExpression(d));
 }
 function unwrapPromise(type) {
   const name = symbolName(type);
@@ -5463,7 +5662,7 @@ function paramSpec(p, location, index) {
   if (optional && !rest) {
     spec = spec.kind === "union" ? spec.options.some((o) => o.kind === "undefined") ? spec : { kind: "union", options: [...spec.options, { kind: "undefined" }] } : spec.kind === "undefined" ? spec : { kind: "union", options: [spec, { kind: "undefined" }] };
   }
-  const name = Node4.isIdentifier(p.getNameNode()) ? p.getName() : `arg${index}`;
+  const name = Node5.isIdentifier(p.getNameNode()) ? p.getName() : `arg${index}`;
   return { name, spec, optional, rest };
 }
 function signatureFromNode(fn) {
@@ -5477,7 +5676,7 @@ function signatureFromCallable(decl) {
   const checker = decl.getProject().getTypeChecker();
   const params = sig.getParameters().map((sym, i) => {
     const pdecl = sym.getValueDeclaration();
-    const isParam = pdecl !== void 0 && Node4.isParameterDeclaration(pdecl);
+    const isParam = pdecl !== void 0 && Node5.isParameterDeclaration(pdecl);
     const rest = isParam && pdecl.isRestParameter();
     const optional = !rest && ((sym.getFlags() & ts4.SymbolFlags.Optional) !== 0 || isParam && (pdecl.isOptional() || pdecl.hasInitializer()));
     let type = checker.getTypeOfSymbolAtLocation(sym, decl);
@@ -5492,7 +5691,7 @@ function signatureFromCallable(decl) {
   return { params, async: unwrapPromise(sig.getReturnType()) !== void 0 };
 }
 function signatureOf(node) {
-  return Node4.isVariableDeclaration(node) ? signatureFromCallable(node) : signatureFromNode(node);
+  return Node5.isVariableDeclaration(node) ? signatureFromCallable(node) : signatureFromNode(node);
 }
 var MAX_UNION_OPTIONS, MAX_PROPS, HANDLED_BUILTINS;
 var init_fromType = __esm({
@@ -5514,21 +5713,21 @@ var init_fromType = __esm({
 });
 
 // src/core/analyze/guards.ts
-import { Node as Node5, SyntaxKind as SyntaxKind4 } from "ts-morph";
+import { Node as Node6, SyntaxKind as SyntaxKind5 } from "ts-morph";
 function compile2(node, params) {
-  if (Node5.isParenthesizedExpression(node)) return compile2(node.getExpression(), params);
-  if (Node5.isNumericLiteral(node)) {
+  if (Node6.isParenthesizedExpression(node)) return compile2(node.getExpression(), params);
+  if (Node6.isNumericLiteral(node)) {
     const v = node.getLiteralValue();
     return () => v;
   }
-  if (Node5.isStringLiteral(node) || Node5.isNoSubstitutionTemplateLiteral(node)) {
+  if (Node6.isStringLiteral(node) || Node6.isNoSubstitutionTemplateLiteral(node)) {
     const v = node.getLiteralValue();
     return () => v;
   }
-  if (node.getKind() === SyntaxKind4.TrueKeyword) return () => true;
-  if (node.getKind() === SyntaxKind4.FalseKeyword) return () => false;
-  if (node.getKind() === SyntaxKind4.NullKeyword) return () => null;
-  if (Node5.isIdentifier(node)) {
+  if (node.getKind() === SyntaxKind5.TrueKeyword) return () => true;
+  if (node.getKind() === SyntaxKind5.FalseKeyword) return () => false;
+  if (node.getKind() === SyntaxKind5.NullKeyword) return () => null;
+  if (Node6.isIdentifier(node)) {
     const name = node.getText();
     if (name === "undefined") return () => void 0;
     if (name === "NaN") return () => NaN;
@@ -5536,7 +5735,7 @@ function compile2(node, params) {
     if (params.has(name)) return (env) => env.get(name);
     return void 0;
   }
-  if (Node5.isPropertyAccessExpression(node) && node.getName() === "length") {
+  if (Node6.isPropertyAccessExpression(node) && node.getName() === "length") {
     const obj = compile2(node.getExpression(), params);
     if (!obj) return void 0;
     return (env) => {
@@ -5544,7 +5743,7 @@ function compile2(node, params) {
       return typeof v === "string" || Array.isArray(v) ? v.length : UNKNOWN;
     };
   }
-  if (Node5.isTypeOfExpression(node)) {
+  if (Node6.isTypeOfExpression(node)) {
     const e = compile2(node.getExpression(), params);
     if (!e) return void 0;
     return (env) => {
@@ -5552,16 +5751,16 @@ function compile2(node, params) {
       return v === UNKNOWN ? UNKNOWN : v === null ? "object" : typeof v;
     };
   }
-  if (Node5.isPrefixUnaryExpression(node)) {
+  if (Node6.isPrefixUnaryExpression(node)) {
     const e = compile2(node.getOperand(), params);
     if (!e) return void 0;
     const op = node.getOperatorToken();
-    if (op === SyntaxKind4.ExclamationToken) return (env) => e(env) === UNKNOWN ? UNKNOWN : !e(env);
-    if (op === SyntaxKind4.MinusToken)
+    if (op === SyntaxKind5.ExclamationToken) return (env) => e(env) === UNKNOWN ? UNKNOWN : !e(env);
+    if (op === SyntaxKind5.MinusToken)
       return (env) => typeof e(env) === "number" ? -e(env) : UNKNOWN;
     return void 0;
   }
-  if (Node5.isCallExpression(node)) {
+  if (Node6.isCallExpression(node)) {
     const callee = node.getExpression().getText().replace(/\s+/g, "");
     const fns = {
       "Number.isInteger": Number.isInteger,
@@ -5582,7 +5781,7 @@ function compile2(node, params) {
       return v === UNKNOWN ? UNKNOWN : fn(v);
     };
   }
-  if (Node5.isBinaryExpression(node)) {
+  if (Node6.isBinaryExpression(node)) {
     const l = compile2(node.getLeft(), params);
     const r = compile2(node.getRight(), params);
     if (!l || !r) return void 0;
@@ -5593,29 +5792,29 @@ function compile2(node, params) {
       return a === UNKNOWN || b === UNKNOWN ? UNKNOWN : f(a, b);
     };
     switch (op) {
-      case SyntaxKind4.LessThanToken:
+      case SyntaxKind5.LessThanToken:
         return cmp((a, b) => a < b);
-      case SyntaxKind4.LessThanEqualsToken:
+      case SyntaxKind5.LessThanEqualsToken:
         return cmp((a, b) => a <= b);
-      case SyntaxKind4.GreaterThanToken:
+      case SyntaxKind5.GreaterThanToken:
         return cmp((a, b) => a > b);
-      case SyntaxKind4.GreaterThanEqualsToken:
+      case SyntaxKind5.GreaterThanEqualsToken:
         return cmp((a, b) => a >= b);
-      case SyntaxKind4.EqualsEqualsEqualsToken:
+      case SyntaxKind5.EqualsEqualsEqualsToken:
         return cmp((a, b) => a === b);
-      case SyntaxKind4.ExclamationEqualsEqualsToken:
+      case SyntaxKind5.ExclamationEqualsEqualsToken:
         return cmp((a, b) => a !== b);
-      case SyntaxKind4.EqualsEqualsToken:
+      case SyntaxKind5.EqualsEqualsToken:
         return cmp((a, b) => a == b);
-      case SyntaxKind4.ExclamationEqualsToken:
+      case SyntaxKind5.ExclamationEqualsToken:
         return cmp((a, b) => a != b);
-      case SyntaxKind4.AmpersandAmpersandToken:
+      case SyntaxKind5.AmpersandAmpersandToken:
         return (env) => {
           const a = l(env);
           if (a === UNKNOWN) return UNKNOWN;
           return a ? r(env) : a;
         };
-      case SyntaxKind4.BarBarToken:
+      case SyntaxKind5.BarBarToken:
         return (env) => {
           const a = l(env);
           if (a === UNKNOWN) return UNKNOWN;
@@ -5628,30 +5827,30 @@ function compile2(node, params) {
   return void 0;
 }
 function isExit(stmt) {
-  if (Node5.isThrowStatement(stmt) || Node5.isReturnStatement(stmt)) return true;
-  if (Node5.isBlock(stmt)) {
+  if (Node6.isThrowStatement(stmt) || Node6.isReturnStatement(stmt)) return true;
+  if (Node6.isBlock(stmt)) {
     const s = stmt.getStatements();
     return s.length >= 1 && isExit(s[s.length - 1]);
   }
   return false;
 }
 function inferGuards(fn) {
-  if (!(Node5.isFunctionDeclaration(fn) || Node5.isFunctionExpression(fn) || Node5.isArrowFunction(fn)))
+  if (!(Node6.isFunctionDeclaration(fn) || Node6.isFunctionExpression(fn) || Node6.isArrowFunction(fn)))
     return void 0;
   const body = fn.getBody();
-  if (!body || !Node5.isBlock(body)) return void 0;
+  if (!body || !Node6.isBlock(body)) return void 0;
   const paramDecls = fn.getParameters();
-  const names = paramDecls.map((p) => Node5.isIdentifier(p.getNameNode()) ? p.getName() : void 0);
+  const names = paramDecls.map((p) => Node6.isIdentifier(p.getNameNode()) ? p.getName() : void 0);
   const params = new Set(names.filter((n3) => !!n3));
   const checks = [];
   for (const stmt of body.getStatements()) {
-    if (Node5.isIfStatement(stmt) && !stmt.getElseStatement() && isExit(stmt.getThenStatement())) {
+    if (Node6.isIfStatement(stmt) && !stmt.getElseStatement() && isExit(stmt.getThenStatement())) {
       const expr = compile2(stmt.getExpression(), params);
       if (expr) checks.push({ text: stmt.getExpression().getText(), expr });
       continue;
     }
-    if (Node5.isExpressionStatement(stmt) && Node5.isCallExpression(stmt.getExpression())) continue;
-    if (Node5.isVariableStatement(stmt) && checks.length === 0) continue;
+    if (Node6.isExpressionStatement(stmt) && Node6.isCallExpression(stmt.getExpression())) continue;
+    if (Node6.isVariableStatement(stmt) && checks.length === 0) continue;
     break;
   }
   if (checks.length === 0) return void 0;
@@ -5754,7 +5953,7 @@ var init_accepts = __esm({
 });
 
 // src/core/verify/verifyFunction.ts
-import { Node as Node6 } from "ts-morph";
+import { Node as Node7 } from "ts-morph";
 function locateExport(sf, exportName) {
   const index = indexModule(sf);
   const top = index.exports.get(exportName);
@@ -5848,11 +6047,16 @@ async function verifyFunction(session, target, options) {
       values: usage.numbers.length + usage.strings.length
     };
   }
-  const guards = Node6.isVariableDeclaration(baseLoc.node) ? void 0 : inferGuards(baseLoc.node);
+  const guards = Node7.isVariableDeclaration(baseLoc.node) ? void 0 : inferGuards(baseLoc.node);
   if (guards) base.guards = guards.conditions;
   const realismCtx = realismContext(usage);
   base.mined = { numbers: mined.numbers.length, strings: mined.strings.length, thresholds: mined.thresholds };
-  const arbitrary = options.arbitrary ?? compileSignature(headSig, { mined });
+  const sizeNames = sizeLikeParams([baseLoc.node, headLoc.node]);
+  const genSig = sizeNames.size === 0 ? headSig : {
+    ...headSig,
+    params: headSig.params.map((p) => sizeNames.has(p.name) ? { ...p, spec: markSize(p.spec) } : p)
+  };
+  const arbitrary = options.arbitrary ?? compileSignature(genSig, { mined });
   if (!arbitrary) return skip("could not build an input generator for the signature");
   let examples = [...usage?.tuples ?? [], ...options.examples ?? []];
   if (options.where) examples = examples.filter((e) => safeWhere(options.where, e));
@@ -5893,10 +6097,10 @@ async function verifyFunction(session, target, options) {
     if (!m.load.exports.includes(target.exportName))
       return skip(`export \`${target.exportName}\` not found at runtime (${label})`);
   }
-  const evaluate = async (inputs) => {
+  const evaluate = async (inputs, opts) => {
     const [b, h] = await Promise.all([
-      session.pools.base.run(baseMod.moduleId, target.exportName, inputs),
-      session.pools.head.run(headMod.moduleId, target.exportName, inputs)
+      session.pools.base.run(baseMod.moduleId, target.exportName, inputs, opts),
+      session.pools.head.run(headMod.moduleId, target.exportName, inputs, opts)
     ]);
     return b.map((o, i) => ({ base: o, head: h[i] }));
   };
@@ -5921,6 +6125,8 @@ async function verifyFunction(session, target, options) {
     flakyClusters: result.flakyClusters,
     stoppedBy: result.stoppedBy,
     failures: result.failures,
+    edgeFailures: result.edgeFailures,
+    skippedEdgeInputs: result.skippedEdgeInputs,
     shrinkEvaluations: result.shrinkEvaluations,
     durationMs: Date.now() - started
   };
@@ -5949,6 +6155,7 @@ var init_verifyFunction = __esm({
     init_compile();
     init_locate();
     init_regex();
+    init_sizeParams();
     init_toplevel();
     init_explore();
     init_fromType();
@@ -6671,7 +6878,7 @@ function exitCodeFor(report, failOn) {
   if (failOn === "any") return report.summary.behaviors > 0 ? 1 : 0;
   return report.summary.unclaimedRealistic > 0 ? 1 : 0;
 }
-var list = (v) => {
+var list2 = (v) => {
   if (v === void 0) return void 0;
   const arr = Array.isArray(v) ? v : [v];
   return arr.flatMap((x) => String(x).split(",")).map((s) => s.trim()).filter(Boolean);
@@ -6774,9 +6981,9 @@ async function runCli(flags) {
       timeoutMs: Number(flags.timeout ?? config.timeoutMs ?? DEFAULT_TIMEOUT_MS),
       ...flags.budget !== void 0 ? { timeBudgetMs: Number(flags.budget) * 1e3 } : {},
       freeze: flags.freeze !== false && config.freeze !== false,
-      ...list(flags.include) ?? config.include ? { include: list(flags.include) ?? config.include } : {},
-      ...list(flags.exclude) ?? config.exclude ? { exclude: [...list(flags.exclude) ?? [], ...config.exclude ?? []] } : {},
-      ...list(flags.only) ? { only: list(flags.only) } : {},
+      ...list2(flags.include) ?? config.include ? { include: list2(flags.include) ?? config.include } : {},
+      ...list2(flags.exclude) ?? config.exclude ? { exclude: [...list2(flags.exclude) ?? [], ...config.exclude ?? []] } : {},
+      ...list2(flags.only) ? { only: list2(flags.only) } : {},
       ...config.compare ? { compare: config.compare } : {},
       ...config.functions ? { functions: config.functions } : {},
       mergeBase: flags.mergeBase !== false,