doppeldiff 0.1.0 → 0.1.1

package/dist/index.js

@@ -330,7 +330,7 @@ var RunnerProcess = class {
   }
   /** 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);
@@ -354,6 +354,11 @@ var RunnerProcess = class {
           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);
@@ -435,18 +440,18 @@ var RunnerPool = class {
     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();
   }
@@ -1046,6 +1051,19 @@ function numberArb(ctx) {
   );
   return weighted(typeDriven, ctx.mined.numbers, ctx);
 }
+var HUGE_SIZES = [2 ** 31 - 1, 2 ** 32, Number.MAX_SAFE_INTEGER, 1e15, Infinity, -Infinity, NaN];
+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);
+}
 var regexCache = /* @__PURE__ */ new WeakMap();
 var sampleCache = /* @__PURE__ */ new WeakMap();
 function regexSamples(arbs) {
@@ -1186,7 +1204,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":
@@ -1416,8 +1434,87 @@ function referencedModuleValues(nodes) {
   return [...result];
 }
 
+// src/core/analyze/sizeParams.ts
+import { Node as Node3, SyntaxKind as SyntaxKind3 } from "ts-morph";
+var 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)$/;
+var LENGTH_CALLS = /* @__PURE__ */ new Set([
+  "repeat",
+  "padStart",
+  "padEnd",
+  "at",
+  "slice",
+  "substring",
+  "substr",
+  "splice"
+]);
+function isLoopCondition(node) {
+  for (let p = node.getParent(); p; p = p.getParent()) {
+    if (Node3.isForStatement(p)) return p.getCondition() !== void 0 && isWithin(node, p.getCondition());
+    if (Node3.isWhileStatement(p) || Node3.isDoStatement(p)) return isWithin(node, p.getExpression());
+    if (Node3.isBlock(p) || Node3.isFunctionLikeDeclaration(p)) return false;
+  }
+  return false;
+}
+function isWithin(node, container) {
+  return node.getPos() >= container.getPos() && node.getEnd() <= container.getEnd();
+}
+function usedAsSize(id) {
+  const parent = id.getParent();
+  if (!parent) return false;
+  if (Node3.isBinaryExpression(parent)) {
+    const op = parent.getOperatorToken().getKind();
+    const comparison = op === SyntaxKind3.LessThanToken || op === SyntaxKind3.LessThanEqualsToken || op === SyntaxKind3.GreaterThanToken || op === SyntaxKind3.GreaterThanEqualsToken;
+    if (comparison && isLoopCondition(parent)) return true;
+  }
+  if (Node3.isElementAccessExpression(parent) && parent.getArgumentExpression() === id) return true;
+  if (Node3.isPropertyAssignment(parent) && parent.getName() === "length" && parent.getInitializer() === id)
+    return true;
+  if (Node3.isShorthandPropertyAssignment(parent) && parent.getName() === "length") return true;
+  if ((Node3.isCallExpression(parent) || Node3.isNewExpression(parent)) && parent.getArguments().includes(id)) {
+    const callee = parent.getExpression();
+    const name = Node3.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 (!(Node3.isFunctionDeclaration(fn) || Node3.isFunctionExpression(fn) || Node3.isArrowFunction(fn)))
+      continue;
+    const params = fn.getParameters().map((p) => p.getNameNode()).filter((n3) => Node3.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(SyntaxKind3.Identifier).filter((id) => id.getText() === name).filter((id) => {
+        const p = id.getParent();
+        return !(Node3.isPropertyAccessExpression(p) && p.getNameNode() === id);
+      });
+      if (refs.some(usedAsSize)) {
+        out.add(name);
+        continue;
+      }
+      for (const decl of body.getDescendantsOfKind(SyntaxKind3.VariableDeclaration)) {
+        const init = decl.getInitializer();
+        const local = decl.getNameNode();
+        if (!init || !Node3.isIdentifier(local) || !refs.some((r) => isWithin(r, init))) continue;
+        const localRefs = body.getDescendantsOfKind(SyntaxKind3.Identifier).filter((id) => id.getText() === local.getText() && id !== local);
+        if (localRefs.some(usedAsSize)) {
+          out.add(name);
+          break;
+        }
+      }
+    }
+  }
+  return out;
+}
+
 // src/core/detect/toplevel.ts
-import { Node as Node3, SyntaxKind as SyntaxKind3, ts as ts2 } from "ts-morph";
+import { Node as Node4, SyntaxKind as SyntaxKind4, ts as ts2 } from "ts-morph";
 function normalize(node) {
   const sf = node.getSourceFile().compilerNode;
   const out = [];
@@ -1435,11 +1532,11 @@ function normalize(node) {
   return out.join(" ");
 }
 function topLevelNameOf(decl) {
-  if (Node3.isFunctionDeclaration(decl) || Node3.isClassDeclaration(decl) || Node3.isEnumDeclaration(decl)) {
+  if (Node4.isFunctionDeclaration(decl) || Node4.isClassDeclaration(decl) || Node4.isEnumDeclaration(decl)) {
     return decl.getName() ?? "default";
   }
-  if (Node3.isVariableDeclaration(decl)) return decl.getName();
-  if (Node3.isExportAssignment(decl)) return "default";
+  if (Node4.isVariableDeclaration(decl)) return decl.getName();
+  if (Node4.isExportAssignment(decl)) return "default";
   return void 0;
 }
 function indexModule(sf) {
@@ -1449,7 +1546,7 @@ function indexModule(sf) {
   const cjsStatements = [];
   const add = (name, kind, node, printed = node) => decls.set(name, { name, kind, node, normalized: normalize(printed), raw: printed.getText() });
   for (const st of sf.getStatements()) {
-    if (Node3.isFunctionDeclaration(st)) {
+    if (Node4.isFunctionDeclaration(st)) {
       const name = st.getName() ?? "default";
       const prev = decls.get(name);
       add(name, "function", st);
@@ -1458,21 +1555,21 @@ function indexModule(sf) {
         cur.normalized = prev.normalized + cur.normalized;
         cur.raw = prev.raw + cur.raw;
       }
-    } else if (Node3.isVariableStatement(st)) {
+    } else if (Node4.isVariableStatement(st)) {
       for (const d of st.getDeclarations()) {
         const nameNode = d.getNameNode();
-        if (Node3.isIdentifier(nameNode)) {
+        if (Node4.isIdentifier(nameNode)) {
           add(d.getName(), "variable", d);
         } else {
-          for (const id of nameNode.getDescendantsOfKind(SyntaxKind3.Identifier))
+          for (const id of nameNode.getDescendantsOfKind(SyntaxKind4.Identifier))
             add(id.getText(), "variable", d);
         }
       }
-    } else if (Node3.isClassDeclaration(st)) {
+    } else if (Node4.isClassDeclaration(st)) {
       add(st.getName() ?? "default", "class", st);
-    } else if (Node3.isEnumDeclaration(st)) {
+    } else if (Node4.isEnumDeclaration(st)) {
       add(st.getName(), "enum", st);
-    } else if (Node3.isImportDeclaration(st)) {
+    } else if (Node4.isImportDeclaration(st)) {
       if (st.isTypeOnly()) continue;
       const spec = st.getModuleSpecifierValue();
       const def = st.getDefaultImport();
@@ -1504,12 +1601,12 @@ function indexModule(sf) {
           raw: `${n3.getName()} from ${spec}`
         });
       }
-    } else if (Node3.isExportAssignment(st)) {
+    } else if (Node4.isExportAssignment(st)) {
       add("default", "default", st);
     } else if (isCjsExport(st)) {
       cjsStatements.push(st);
       continue;
-    } else if (Node3.isInterfaceDeclaration(st) || Node3.isTypeAliasDeclaration(st) || Node3.isExportDeclaration(st) || Node3.isModuleDeclaration(st) || Node3.isEmptyStatement(st)) {
+    } else if (Node4.isInterfaceDeclaration(st) || Node4.isTypeAliasDeclaration(st) || Node4.isExportDeclaration(st) || Node4.isModuleDeclaration(st) || Node4.isEmptyStatement(st)) {
       continue;
     } else {
       sideEffects.push(normalize(st));
@@ -1530,9 +1627,9 @@ function indexModule(sf) {
   return { sf, decls, sideEffects, exports };
 }
 function isCjsExport(st) {
-  if (!Node3.isExpressionStatement(st)) return false;
+  if (!Node4.isExpressionStatement(st)) return false;
   const expr = st.getExpression();
-  return Node3.isBinaryExpression(expr) && expr.getOperatorToken().getKind() === SyntaxKind3.EqualsToken && cjsTarget(expr.getLeft()) !== void 0;
+  return Node4.isBinaryExpression(expr) && expr.getOperatorToken().getKind() === SyntaxKind4.EqualsToken && cjsTarget(expr.getLeft()) !== void 0;
 }
 function cjsTarget(left) {
   const text2 = left.getText().replace(/\s+/g, "");
@@ -1541,19 +1638,19 @@ function cjsTarget(left) {
   return m ? m[1] : void 0;
 }
 function cjsExport(st, decls, exportsMap, add) {
-  if (!Node3.isExpressionStatement(st)) return false;
+  if (!Node4.isExpressionStatement(st)) return false;
   const expr = st.getExpression();
-  if (!Node3.isBinaryExpression(expr) || expr.getOperatorToken().getKind() !== SyntaxKind3.EqualsToken)
+  if (!Node4.isBinaryExpression(expr) || expr.getOperatorToken().getKind() !== SyntaxKind4.EqualsToken)
     return false;
   const target = cjsTarget(expr.getLeft());
   if (target === void 0) return false;
   const bind = (exportName, value) => {
-    if (Node3.isIdentifier(value) && decls.has(value.getText())) {
+    if (Node4.isIdentifier(value) && decls.has(value.getText())) {
       exportsMap.set(exportName, value.getText());
       return;
     }
     const synthetic = `exports.${exportName}`;
-    const isFn = Node3.isArrowFunction(value) || Node3.isFunctionExpression(value);
+    const isFn = Node4.isArrowFunction(value) || Node4.isFunctionExpression(value);
     add(synthetic, isFn ? "function" : "variable", value);
     exportsMap.set(exportName, synthetic);
   };
@@ -1562,12 +1659,12 @@ function cjsExport(st, decls, exportsMap, add) {
     bind(target, rhs);
     return true;
   }
-  if (Node3.isObjectLiteralExpression(rhs)) {
+  if (Node4.isObjectLiteralExpression(rhs)) {
     for (const prop of rhs.getProperties()) {
-      if (Node3.isShorthandPropertyAssignment(prop)) bind(prop.getName(), prop.getNameNode());
-      else if (Node3.isPropertyAssignment(prop))
+      if (Node4.isShorthandPropertyAssignment(prop)) bind(prop.getName(), prop.getNameNode());
+      else if (Node4.isPropertyAssignment(prop))
         bind(prop.getName().replace(/^['"]|['"]$/g, ""), prop.getInitializerOrThrow());
-      else if (Node3.isMethodDeclaration(prop)) {
+      else if (Node4.isMethodDeclaration(prop)) {
         add(`exports.${prop.getName()}`, "variable", prop);
         exportsMap.set(prop.getName(), `exports.${prop.getName()}`);
       }
@@ -1594,13 +1691,13 @@ function reach(index, start, depth) {
   for (let d = 0; d < depth && frontier.length > 0; d++) {
     const next = [];
     for (const { node, path } of frontier) {
-      for (const id of node.getDescendantsOfKind(SyntaxKind3.Identifier)) {
+      for (const id of node.getDescendantsOfKind(SyntaxKind4.Identifier)) {
         const name = id.getText();
         const top = index.decls.get(name);
         if (!top || local.has(name) || top.node === start) continue;
         const sym = id.getSymbol();
         const decls = sym?.getDeclarations() ?? [];
-        if (sym && !decls.some((dn) => isWithin(dn, top.node))) continue;
+        if (sym && !decls.some((dn) => isWithin2(dn, top.node))) continue;
         if (top.kind === "import") {
           const aliased = sym?.isAlias() ? sym.getAliasedSymbol() : void 0;
           for (const ad of aliased?.getDeclarations() ?? []) {
@@ -1623,7 +1720,7 @@ function reach(index, start, depth) {
   }
   return { local, imported };
 }
-function isWithin(node, ancestor) {
+function isWithin2(node, ancestor) {
   for (let cur = node; cur; cur = cur.getParent()) if (cur === ancestor) return true;
   return false;
 }
@@ -1797,6 +1894,13 @@ function num(n3) {
   if (Object.is(n3, -0)) return "-0";
   return String(n3);
 }
+var MAX_ITEMS = 10;
+var SHOWN_ITEMS = 6;
+var abbreviateLists = true;
+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`;
+}
 var IDENT = /^[A-Za-z_$][\w$]*$/;
 var key = (k) => IDENT.test(k) ? k : JSON.stringify(k);
 function formatValue(v, max = MAX_LEN) {
@@ -1826,12 +1930,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];
@@ -1845,7 +1948,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);
     }
@@ -1855,7 +1958,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":
@@ -1873,18 +1985,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":
@@ -1892,7 +2004,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":
@@ -1903,12 +2015,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":
@@ -2213,6 +2325,10 @@ function biasFor(runIndex) {
   return 2 + Math.floor(Math.log(runIndex + 1) / Math.log(10));
 }
 var size = (input) => formatArgs(input, 1e4).length;
+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,
@@ -2225,6 +2341,8 @@ async function explore(options) {
     shrinkBudget = 500,
     maxWitnesses = 3,
     maxFailures = 20,
+    maxEdgeFailures = 2,
+    maxTimeoutChecks = 12,
     selfCheck = 50,
     humanizeBudget = 150
   } = options;
@@ -2242,7 +2360,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;
@@ -2261,8 +2385,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);
@@ -2276,9 +2422,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));
@@ -2353,12 +2500,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;
@@ -2371,7 +2520,7 @@ async function explore(options) {
       stoppedBy = "deadline";
       break;
     }
-    if (failures >= maxFailures) {
+    if (realisticFailures() >= maxFailures) {
       stoppedBy = "failures";
       break;
     }
@@ -2397,9 +2546,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;
@@ -2409,6 +2562,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) {
@@ -2435,7 +2594,7 @@ async function explore(options) {
           break;
         }
       }
-      if (failures >= maxFailures * 2) break;
+      if (realisticFailures() >= maxFailures * 2) break;
     }
     shrinkEvaluations += evals;
     const sameCluster = async (candidates) => {
@@ -2450,7 +2609,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 = {
@@ -2468,7 +2629,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);
     }
@@ -2500,13 +2661,15 @@ async function explore(options) {
     flakyClusters,
     stoppedBy,
     shrinkEvaluations,
-    failures
+    failures,
+    edgeFailures,
+    skippedEdgeInputs
   };
 }
 
 // src/core/types/fromType.ts
 import {
-  Node as Node4,
+  Node as Node5,
   ts as ts3
 } from "ts-morph";
 
@@ -2611,6 +2774,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;
+}
 
 // src/core/types/fromType.ts
 var MAX_UNION_OPTIONS = 64;
@@ -2753,7 +2921,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);
@@ -2832,7 +3000,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) {
@@ -2846,7 +3014,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() & ts3.SymbolFlags.Optional) !== 0 || isParam && (pdecl.isOptional() || pdecl.hasInitializer()));
     let type = checker.getTypeOfSymbolAtLocation(sym, decl);
@@ -2861,26 +3029,26 @@ 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);
 }
 
 // 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";
 var UNKNOWN = /* @__PURE__ */ Symbol("unknown");
 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;
@@ -2888,7 +3056,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) => {
@@ -2896,7 +3064,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) => {
@@ -2904,16 +3072,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,
@@ -2934,7 +3102,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;
@@ -2945,29 +3113,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;
@@ -2980,30 +3148,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;
@@ -3113,7 +3281,7 @@ function inputRealism(input, ctx) {
 }
 
 // src/core/verify/verifyFunction.ts
-import { Node as Node6 } from "ts-morph";
+import { Node as Node7 } from "ts-morph";
 
 // src/core/types/accepts.ts
 function accepts(base, head) {
@@ -3279,11 +3447,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));
@@ -3324,10 +3497,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] }));
   };
@@ -3352,6 +3525,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
   };
@@ -5047,6 +5222,10 @@ var FunctionReport = z.object({
   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(),
@@ -5151,14 +5330,14 @@ function applyRuleLabels(report, forceRefactor = false) {
   return report;
 }
 var MAX_DISPLAY = 300;
-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 } : {}
       };
     }
@@ -5167,7 +5346,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) } : {}
       };
     }
@@ -5184,16 +5363,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 } : {}
       };
     }
@@ -5225,6 +5409,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 } : {},
@@ -5406,6 +5592,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 = {
@@ -5418,7 +5616,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>"
     );