perf(schema): reduce retained integer validator allocations (#4360)

Construct integer formats directly while preserving bounds, refinements, metadata and current shared schema owners. Keep Incur-dependent CLI numeric coercion declarations unchanged.

Verify canonical advertisements, 126 numeric boundary cases, 974 actual CLI parser cases, broad source tests and real public-artifact SDK workflows. Record 72 normal tasks and 12 separate owned-inspector heap diagnostics with whole-family resource bounds; distinguish SDK spans and asymmetric audit overhead. Generate numerical report sections from receipts and reject stale tables through documentation conformance checks.

Closes #6236. Current-head CI and Greptile pass; actionable review findings are addressed. Codex review was unavailable due repository usage limits.

experiments/analysis-efficiency/mcp-input-catalog.mjs

@@ -7,6 +7,7 @@ import { parseArgs } from "node:util";
 import { Client } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { Ajv2020 } from "ajv/dist/2020.js";
+import { sampleRetainedHeap } from "./mcp-retained-heap.mjs";
 import {
   captureRuntimeBinding,
   assertRuntimeBinding,
@@ -24,10 +25,12 @@ const { values } = parseArgs({
     "cache-root": { type: "string" },
     bindings: { type: "string" },
     role: { type: "string" },
+    "diagnostic-heap": { type: "boolean", default: false },
   },
 });
 assert.ok(["analysis", "discovery"].includes(values.phase));
 assert.ok(["cold", "warm"].includes(values.cache));
+assert.ok(!values["diagnostic-heap"] || values.phase === "analysis");
 for (const key of values.phase === "analysis"
   ? ["runtime", "artifact", "oracle", "output"]
   : ["runtime", "output"])
@@ -60,7 +63,11 @@ if (values.bindings !== undefined) {
   const inputBytes = await readFile(values.bindings);
   measurementInputsSha256 = hash(inputBytes);
   const inputs = JSON.parse(inputBytes.toString("utf8"));
-  for (const name of ["mcp-input-catalog.mjs", "managed-cli-runtime.mjs"]) {
+  for (const name of [
+    "mcp-input-catalog.mjs",
+    "managed-cli-runtime.mjs",
+    "mcp-retained-heap.mjs",
+  ]) {
     producerSources[name] = hash(
       await readFile(new URL(name, import.meta.url)),
     );
@@ -87,7 +94,11 @@ const environment = {
 };
 const transport = new StdioClientTransport({
   command: process.execPath,
-  args: [join(values.runtime, "scripts/rea.mjs"), "mcp"],
+  args: [
+    ...(values["diagnostic-heap"] ? ["--inspect=127.0.0.1:0"] : []),
+    join(values.runtime, "scripts/rea.mjs"),
+    "mcp",
+  ],
   cwd: values.output,
   env: environment,
   stderr: "pipe",
@@ -118,8 +129,13 @@ const report = {
 };
 const transcript = [];
 let stderr = "";
+let inspectorEndpoint;
 transport.stderr?.on("data", (value) => {
   stderr += value;
+  if (values["diagnostic-heap"] && inspectorEndpoint === undefined)
+    inspectorEndpoint = stderr.match(
+      /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[^\s]+)/u,
+    )?.[1];
 });
 const began = performance.now();
 try {
@@ -255,6 +271,15 @@ try {
     );
     report.status = "passed";
   }
+  if (values["diagnostic-heap"]) {
+    report.status = "incomplete";
+    assert.ok(inspectorEndpoint, "Missing explicitly launched inspector");
+    report.diagnostic_heap = await sampleRetainedHeap(
+      inspectorEndpoint,
+      transport.pid,
+    );
+    report.status = "passed";
+  }
 } finally {
   await client.close();
   await transport.close();

experiments/analysis-efficiency/mcp-integer-allocation.md

@@ -0,0 +1,143 @@
+# Integer validator allocation after MCP materialization
+
+Issue #6236; PR #4360. Linux x64, 2026-10-22.
+
+<!-- BEGIN:allocation-report:provenance -->
+
+Baseline `main@4a4bbab3c337701febeb6b532ace49041c4876e0`; candidate `461f342c71a72ef2be60912391df2393aa4e2ea3`. This is a pinned comparison.
+
+In separate inspector/forced-GC diagnostics, retained REA V8 heap decreases by about 9.6 MiB. The three-pair ranges do not overlap in either profile. Inspector perturbation is included. Normal task timing, CPU and peak memory are reported separately; these observations do not establish a general latency or peak-memory reduction.
+
+<!-- END:allocation-report:provenance -->
+
+Directory discovery uses recorded advertisements after #4424; this study separates it from completed tasks that materialize canonical handlers. Context is unchanged.
+
+## Change and compatibility
+
+Replace 1,247 argument-free `z.number().int()` constructions with `z.int()` across 175 existing source files. Keep current shared schema owners, refinements, bounds, defaults and metadata. AST-token comparison against the baseline, after normalizing this construction and formatting, is equal for every touched source file. No new tools, provider effects, caches or response contracts.
+
+The locked Zod 4.4.3 chained form retains a `ZodNumber` with a separate `ZodNumberFormat` check; direct construction uses the format itself. Incur 0.6.1 coerces argv strings only for `ZodNumber`. Existing CLI declarations and shared-input exceptions therefore retain the chained form. The actual compiled CLI registers 160 leaf commands; 104 numeric argument/option fields have identical results/errors in 974 installed-Incur parser cases across both runtimes, each field with an accepted probe. Fields are isolated from unrelated required options and no handlers are invoked. This is consumer-boundary coverage, not a real-engine claim.
+
+Seven dependency-boundary variants match parsed values and complete error issues for 126 cases, including fractions, nonfinite values, strings/null/undefined and unsafe integers; 14 JSON Schema projections match in draft-07/draft-2020-12. Actual SDK advertisements match byte-for-byte in both profiles before/after materialization and across roles.
+
+## Tasks, artifacts and bounds
+
+Reuse the shared SDK task driver and independent ELF/section/zlib/JSON oracles from [the catalog study](mcp-input-catalog.md): official Alpine v3.21 x86_64 ripgrep 14.1.1-r0 and Zellij 0.40.0-r0. All 42/422 packages and 88/1,063 edges match the independent oracles. Select serde name/version/kind, repeat exact retained-parent reads twice, verify a canonical negative-offset refusal, export/check complete Evidence and confirm the unchanged directory. `kind: null` stays unknown. Targets are not executed; dependency presence does not establish runtime use. Acquisition URLs, archive/executable/oracle hashes and complete answers are in [the receipts](mcp-integer-allocation.json). Previously acquired public bytes are rehashed, not redownloaded.
+
+Normal cohort: three alternating baseline/candidate pairs for each task × cold/warm server compile cache × default compact/full inputs: 72 trials, plus four excluded full-task warm priming runs. Separate diagnostic cohort: three alternating pairs per profile, cold Zellij tasks, 12 trials. All pass, with identical complete parent IDs/hashes and answers.
+
+Node 24.18.0/npm 11.16.0; fresh client/server and HOME per trial, driver compile cache disabled. Each trial is serial, pinned to one CPU, 4 GiB hard/3 GiB early stop, no swap, at most 192 tasks. Before/after checks bind clean source, all compiled JS/JSON assets (1,990 baseline / 1,990 candidate files), scripts and manifests; producer and resource-observer hashes are also bound. No OOM, resource stop or leftover payload processes. Whole-family measurements include SDK validation, extra calls, source/compiled audits and oracle checking; kernel peak includes file cache. Build/acquisition/oracle generation and priming are excluded. Warm uses a populated role/profile-specific Node cache; hit rate and OS page cache are unmeasured, and audits warm compiled-file pages.
+
+## Normal task costs
+
+Medians, baseline → candidate; all ranges are in the JSON. No inspector or diagnostic GC runs in this cohort.
+
+<!-- BEGIN:allocation-report:normal -->
+
+| Task      | Cache | Input profile |          Wall s |    Family CPU s | Family peak MiB |
+| --------- | ----- | ------------- | --------------: | --------------: | --------------: |
+| directory | cold  | default       |   2.739 → 2.239 |   2.553 → 2.075 |   247.4 → 248.4 |
+| directory | cold  | full          |   2.940 → 2.437 |   2.682 → 2.217 |   348.0 → 346.8 |
+| directory | warm  | default       |   2.639 → 2.135 |   2.461 → 1.980 |   251.8 → 246.2 |
+| directory | warm  | full          |   2.840 → 2.338 |   2.666 → 2.144 |   348.6 → 347.2 |
+| ripgrep   | cold  | default       |   7.571 → 7.169 |   7.372 → 6.918 |   798.8 → 791.1 |
+| zellij    | cold  | default       |   7.876 → 7.373 |   7.623 → 7.134 |   812.2 → 810.5 |
+| ripgrep   | cold  | full          |   7.876 → 7.475 |   7.710 → 7.295 |   803.7 → 801.2 |
+| zellij    | cold  | full          |   8.079 → 7.573 |   7.852 → 7.378 |   815.7 → 819.1 |
+| ripgrep   | warm  | default       |   7.575 → 6.977 |   7.352 → 6.810 |   815.0 → 791.6 |
+| zellij    | warm  | default       |   7.774 → 7.178 |   7.581 → 6.981 |   820.9 → 822.0 |
+| ripgrep   | warm  | full          |   7.976 → 7.875 |   7.746 → 7.679 |   812.7 → 789.3 |
+| zellij    | warm  | full          | 14.995 → 13.978 | 14.742 → 13.718 |   818.5 → 811.5 |
+
+<!-- END:allocation-report:normal -->
+
+### SDK span and audit separation
+
+<!-- BEGIN:allocation-report:sdk -->
+
+Cold/default directory audit wall medians are 1.273 s baseline / 0.782 s candidate; SDK spans are 0.944 → 0.948 s. Whole-family costs include those experimental audits. Their cause and per-span CPU are unmeasured.
+
+SDK span from client connect through task checks and client/server close. Excludes pre/post runtime binding and preflight artifact/oracle loading. Diagnostic spans include inspector and forced GC. CPU is measured for the whole family only; per-span CPU is unmeasured.
+
+| Task      | Cache | Inputs  | SDK span s, baseline → candidate |
+| --------- | ----- | ------- | -------------------------------: |
+| directory | cold  | default |                    0.944 → 0.948 |
+| directory | cold  | full    |                    1.067 → 1.102 |
+| directory | warm  | default |                    0.888 → 0.878 |
+| directory | warm  | full    |                    1.038 → 1.042 |
+| ripgrep   | cold  | default |                    5.778 → 5.752 |
+| zellij    | cold  | default |                    5.998 → 5.991 |
+| ripgrep   | cold  | full    |                    6.077 → 6.119 |
+| zellij    | cold  | full    |                    6.228 → 6.209 |
+| ripgrep   | warm  | default |                    5.743 → 5.656 |
+| zellij    | warm  | default |                    5.965 → 5.788 |
+| ripgrep   | warm  | full    |                    6.100 → 6.492 |
+| zellij    | warm  | full    |                  11.776 → 11.529 |
+
+<!-- END:allocation-report:sdk -->
+
+Full-profile warm Zellij is slower than its cold condition in both roles in this cohort. Cache hit rate and the cause of this observation are unmeasured, and cold/warm groups run sequentially. These timings support neither a general cache speedup nor a causal regression attribution.
+
+## Separate retained-heap diagnostics
+
+The same completed SDK task launches only its owned REA process with `--inspect=127.0.0.1:0`. Four CDP calls verify the owned transport PID, read heap, force GC and read heap again. The endpoint comes from that child’s stderr; the PID is a cross-check of the owned endpoint, not sole ownership proof. The inspector socket closes before MCP shutdown. These V8 values include inspector perturbation and exclude the client; diagnostic wall/CPU/family peaks include inspector and forced-GC overhead and are not normal-task timing results.
+
+<!-- BEGIN:allocation-report:heap -->
+
+| Inputs  | REA V8 retained MiB |  Baseline range | Candidate range | Diagnostic wall s |           CPU s | Family peak MiB |
+| ------- | ------------------: | --------------: | --------------: | ----------------: | --------------: | --------------: |
+| default |   189.835 → 180.242 | 189.823–189.855 | 180.208–180.366 |   15.490 → 14.291 | 15.246 → 14.123 |   814.1 → 786.3 |
+| full    |   191.260 → 181.693 | 191.165–191.304 | 181.588–181.848 |     8.979 → 8.377 |   8.769 → 8.142 |   810.3 → 824.9 |
+
+<!-- END:allocation-report:heap -->
+
+A mismatched PID is rejected; removing only that guard makes the negative oracle fail. Both connections in that check use the same owned REA endpoint, with no foreign-process attachment. Aggregation rejects diagnostic GC in a normal trial. Historical #4424 receipt reaggregation preserves previous metrics and adds the separately reported SDK-span fields; its aggregator source hash changes.
+
+## Context accounting
+
+<!-- BEGIN:allocation-report:context -->
+
+tiktoken==0.14.0/cl100k_base; estimates, not model usage. Actual model usage is unmeasured.
+
+| Profile | Input directory once | Directory task | ripgrep task | Zellij task |
+| ------- | -------------------: | -------------: | -----------: | ----------: |
+| default |               49,670 |         50,840 |       54,029 |      53,949 |
+| full    |              205,744 |        206,914 |      210,103 |     210,023 |
+
+Raw SDK directory costs per list: 756,165/912,436 tokens and 2,935,148/3,587,792 bytes for default/full.
+
+Question, explicit recipe, server instructions, one complete name/description/input-schema directory, every tool argument and text reply, plus prompt directory for discovery. This projection assumes the client retains a single unchanged directory. Raw catalog result costs include every observed tools/list result separately, with output schemas and without JSON-RPC envelopes. SDK initialization/framing, reasoning and actual model usage are unmeasured. The analysis task includes retained-read, rejection, export/oracle and post-materialization directory checks.
+
+<!-- END:allocation-report:context -->
+
+## Validation and reproduction
+
+- Both runtime builds and all six static checks plus architecture guards pass. Before the final main synchronization, 5,972 source/contract/public CLI/MCP tests pass across 323 files; four skip for unavailable/guarded coverage. After synchronization, both builds/static checks repeat successfully, 77 affected producer and CLI/MCP tests pass, and all 974 registered numeric-parameter parser cases match again. Includes real SQLite CLI/MCP record/column selection and JavaScript heap/deadline preservation. A first direct schema-validity invocation lacked generated catalog metadata; the supported focused entry generates it and all 15 cases pass. A later affected-test invocation selected two nonexistent paths; the corrected three-file producer/consumer run is the 77-case result above. Neither setup failure was counted as a passing test, and no production or timeout change was needed.
+- All 84 measured tasks and four warm priming tasks pass independent oracles, canonical refusal, parent/directory identity and owned cleanup checks. This does not verify external Hopper/Ghidra/IDA, Android devices, all providers or foreign OS behavior. The earlier macOS numbers in #4360 describe a different revision/platform and are not combined with these results.
+
+Build the pinned baseline/candidate in separate clean worktrees with the locked toolchain. Use the candidate’s producer scripts for both roles. `measurement_inputs` in the JSON records the complete matrix, questions/recipes, runtime bindings and producer hashes; extract it unchanged as the bindings file. Historical receipts require their matching producer revision. One normal task:
+
+```bash
+NODE_DISABLE_COMPILE_CACHE=1 node experiments/analysis-efficiency/mcp-input-catalog.mjs \
+  --runtime "$CANDIDATE_RUNTIME" --bindings "$MEASUREMENT_INPUTS" --role candidate \
+  --artifact "$RIPGREP_BINARY" --oracle "$RIPGREP_ORACLE" \
+  --output "$NEW_CASE_DIRECTORY" --profile default --phase analysis --cache cold
+```
+
+Run each task through `resource-run.py --observe-payload-exit --` to obtain whole-family counters. For warm runs replace `--cache cold` with `--cache warm --cache-root <role/profile cache>` after one complete priming task. For the separate Zellij diagnostic tasks add `--diagnostic-heap` and use cold cache. Keep their case names/logs aligned with `measurement_inputs`; aggregate both cohorts with:
+
+```bash
+python experiments/analysis-efficiency/mcp-startup-costs.py "$RECEIPT_ROOT" \
+  --output mcp-integer-allocation.json
+```
+
+The aggregator requires the recorded tiktoken version, exact catalog/parent/runtime/producer/guard identities, clean source, successful payload cleanup and matching matrix coverage. Default driver behavior continues without an inspector; the heap flag is confined to the experiment.
+
+Regenerate or verify every numerical section directly from the committed JSON:
+
+```bash
+node experiments/analysis-efficiency/mcp-integer-report.mjs
+node experiments/analysis-efficiency/mcp-integer-report.mjs --check
+```
+
+The documentation conformance gate checks current receipts, rejects stale normal/heap tables, and refuses missing producer markers without writing.

experiments/analysis-efficiency/mcp-integer-report.mjs

@@ -0,0 +1,212 @@
+// One producer for the numerical sections of the committed allocation report.
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+
+const { values } = parseArgs({
+  options: {
+    data: { type: "string" },
+    markdown: { type: "string" },
+    check: { type: "boolean", default: false },
+  },
+});
+const dataPath =
+  values.data ?? new URL("mcp-integer-allocation.json", import.meta.url);
+const markdownPath =
+  values.markdown ?? new URL("mcp-integer-allocation.md", import.meta.url);
+const data = JSON.parse(await readFile(dataPath, "utf8"));
+assert.equal(data.status, "passed");
+const original = await readFile(markdownPath, "utf8");
+const fixed = (value, digits = 3) => {
+  assert.ok(Number.isFinite(value));
+  return value.toFixed(digits);
+};
+const mib = (value, digits = 1) => fixed(value / 2 ** 20, digits);
+const median = (values) => {
+  assert.ok(values.length > 0);
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2
+    ? sorted[middle]
+    : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+const table = (headers, rows, right = []) =>
+  [
+    `| ${headers.join(" | ")} |`,
+    `| ${headers.map((_, index) => (right.includes(index) ? "---:" : "---")).join(" | ")} |`,
+    ...rows.map((row) => `| ${row.join(" | ")} |`),
+  ].join("\n");
+const pair = (item, key, format = fixed) =>
+  `${format(item.baseline[key].median)} → ${format(item.candidate[key].median)}`;
+const heapMetric = "retained_v8_heap_bytes_after_gc";
+const heaps = data.heap_diagnostics.summary;
+const changes = heaps.map(
+  (item) =>
+    (item.baseline[heapMetric].median - item.candidate[heapMetric].median) /
+    2 ** 20,
+);
+const changesText = [...new Set(changes.map((value) => fixed(value, 1)))].join(
+  "–",
+);
+const separated = heaps.every(
+  (item) => item.baseline[heapMetric].min > item.candidate[heapMetric].max,
+);
+const provenance = `Baseline \`main@${data.measurement_inputs.baseline_revision}\`; candidate \`${data.measurement_inputs.candidate_revision}\`. This is a pinned comparison.\n\nIn separate inspector/forced-GC diagnostics, retained REA V8 heap decreases by about ${changesText} MiB. ${separated ? "The three-pair ranges do not overlap in either profile." : "Ranges overlap; inspect the observations below."} Inspector perturbation is included. Normal task timing, CPU and peak memory are reported separately; these observations do not establish a general latency or peak-memory reduction.`;
+const normal = table(
+  [
+    "Task",
+    "Cache",
+    "Input profile",
+    "Wall s",
+    "Family CPU s",
+    "Family peak MiB",
+  ],
+  data.summary.map((item) => [
+    item.artifact ?? "directory",
+    item.cache,
+    item.profile,
+    pair(item, "wall_seconds"),
+    pair(item, "cpu_seconds"),
+    pair(item, "kernel_family_peak_bytes_including_page_cache", mib),
+  ]),
+  [3, 4, 5],
+);
+const discovery = data.summary.find(
+  (item) =>
+    item.phase === "discovery" &&
+    item.cache === "cold" &&
+    item.profile === "default",
+);
+assert.ok(discovery);
+const audit = (role) =>
+  median(
+    data.records
+      .filter(
+        (row) =>
+          row.phase === "discovery" &&
+          row.cache === "cold" &&
+          row.profile === "default" &&
+          row.role === role,
+      )
+      .map(
+        (row) =>
+          (row.runtime_audit_ms.before + row.runtime_audit_ms.after) / 1000,
+      ),
+  );
+const sdk =
+  `Cold/default directory audit wall medians are ${fixed(audit("baseline"))} s baseline / ${fixed(audit("candidate"))} s candidate; SDK spans are ${pair(discovery, "sdk_task_elapsed_seconds")} s. Whole-family costs include those experimental audits. Their cause and per-span CPU are unmeasured.\n\n${data.sdk_task_elapsed_scope}\n\n` +
+  table(
+    ["Task", "Cache", "Inputs", "SDK span s, baseline → candidate"],
+    data.summary.map((item) => [
+      item.artifact ?? "directory",
+      item.cache,
+      item.profile,
+      pair(item, "sdk_task_elapsed_seconds"),
+    ]),
+    [3],
+  );
+const heap = table(
+  [
+    "Inputs",
+    "REA V8 retained MiB",
+    "Baseline range",
+    "Candidate range",
+    "Diagnostic wall s",
+    "CPU s",
+    "Family peak MiB",
+  ],
+  heaps.map((item) => [
+    item.profile,
+    pair(item, heapMetric, (value) => mib(value, 3)),
+    ...["baseline", "candidate"].map(
+      (role) =>
+        `${mib(item[role][heapMetric].min, 3)}–${mib(item[role][heapMetric].max, 3)}`,
+    ),
+    pair(item, "wall_seconds"),
+    pair(item, "cpu_seconds"),
+    pair(item, "kernel_family_peak_bytes_including_page_cache", mib),
+  ]),
+  [1, 2, 3, 4, 5, 6],
+);
+const integer = (value) => new Intl.NumberFormat("en-US").format(value);
+const tokens = (profile, phase, artifact) => {
+  const values = data.records
+    .filter(
+      (row) =>
+        row.profile === profile &&
+        row.phase === phase &&
+        row.artifact === artifact,
+    )
+    .map((row) => row.tokens_estimated.whole_task);
+  assert.ok(values.length > 0);
+  return [...new Set([Math.min(...values), Math.max(...values)])]
+    .map(integer)
+    .join("–");
+};
+const catalogs = data.catalogs;
+const context =
+  `${data.tokenizer}. Actual model usage is unmeasured.\n\n` +
+  table(
+    [
+      "Profile",
+      "Input directory once",
+      "Directory task",
+      "ripgrep task",
+      "Zellij task",
+    ],
+    ["default", "full"].map((profile) => [
+      profile,
+      integer(catalogs[profile].input_catalog_tokens),
+      tokens(profile, "discovery", null),
+      tokens(profile, "analysis", "ripgrep"),
+      tokens(profile, "analysis", "zellij"),
+    ]),
+    [1, 2, 3, 4],
+  ) +
+  `\n\nRaw SDK directory costs per list: ${integer(catalogs.default.raw_catalog_tokens)}/${integer(catalogs.full.raw_catalog_tokens)} tokens and ${integer(catalogs.default.raw_catalog_bytes)}/${integer(catalogs.full.raw_catalog_bytes)} bytes for default/full.\n\n${data.context_scope}`;
+const sections = { provenance, normal, sdk, heap, context };
+// oxfmt may pad table cells and separator dashes; neither changes report facts.
+const normalized = (value) =>
+  value
+    .trim()
+    .replace(/\s+/gu, " ")
+    .replace(/\s*\|\s*/gu, "|")
+    .replace(
+      /(?<=\|)(:)?-{3,}(:)?(?=\|)/gu,
+      (_, left, right) => `${left ?? ""}---${right ?? ""}`,
+    );
+let rendered = original;
+const changed = [];
+for (const [name, content] of Object.entries(sections)) {
+  const begin = `<!-- BEGIN:allocation-report:${name} -->`;
+  const end = `<!-- END:allocation-report:${name} -->`;
+  assert.equal(
+    rendered.split(begin).length,
+    2,
+    `Expected one opening report marker: ${name}`,
+  );
+  assert.equal(
+    rendered.split(end).length,
+    2,
+    `Expected one closing report marker: ${name}`,
+  );
+  const start = rendered.indexOf(begin) + begin.length;
+  const finish = rendered.indexOf(end);
+  assert.ok(finish > start, `Invalid report marker order: ${name}`);
+  if (normalized(rendered.slice(start, finish)) !== normalized(content)) {
+    changed.push(name);
+    rendered =
+      rendered.slice(0, start) + `\n\n${content}\n\n` + rendered.slice(finish);
+  }
+}
+if (values.check) {
+  assert.equal(
+    changed.length,
+    0,
+    `Generated allocation report differs: ${changed.join(", ")}`,
+  );
+  console.log("Allocation report matches committed receipt data");
+} else if (changed.length) {
+  await writeFile(markdownPath, rendered);
+  console.log(`Updated allocation report sections: ${changed.join(", ")}`);
+}

experiments/analysis-efficiency/mcp-retained-heap.mjs

@@ -0,0 +1,107 @@
+// Diagnostic only: inspect the explicitly launched REA process after its task.
+import assert from "node:assert/strict";
+
+export const sampleRetainedHeap = async (endpoint, expectedPid) => {
+  const url = new URL(endpoint);
+  assert.equal(url.protocol, "ws:");
+  assert.equal(url.hostname, "127.0.0.1");
+  assert.ok(Number.isSafeInteger(expectedPid) && expectedPid > 0);
+  const socket = new WebSocket(url);
+  let sequence = 0;
+  const pending = new Map();
+  const closed = new Promise((resolve) => {
+    socket.addEventListener("close", resolve, { once: true });
+  });
+  const rejectPending = (cause) => {
+    for (const request of pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(cause);
+    }
+    pending.clear();
+  };
+  socket.addEventListener("error", () =>
+    rejectPending(new Error("Owned REA inspector connection failed")),
+  );
+  socket.addEventListener("close", () =>
+    rejectPending(new Error("Owned REA inspector connection closed")),
+  );
+  socket.addEventListener("message", (event) => {
+    try {
+      const reply = JSON.parse(event.data);
+      const request = pending.get(reply.id);
+      if (request === undefined) return;
+      pending.delete(reply.id);
+      clearTimeout(request.timer);
+      if (reply.error !== undefined)
+        request.reject(new Error(JSON.stringify(reply.error)));
+      else request.resolve(reply.result);
+    } catch (cause) {
+      rejectPending(cause);
+    }
+  });
+  const withinDeadline = async (promise) => {
+    let timer;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("Owned REA inspector deadline exceeded")),
+            10_000,
+          );
+        }),
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const call = (method, params = {}) =>
+    new Promise((resolve, reject) => {
+      const id = ++sequence;
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`Owned REA inspector timed out: ${method}`));
+      }, 10_000);
+      pending.set(id, { resolve, reject, timer });
+      try {
+        socket.send(JSON.stringify({ id, method, params }));
+      } catch (cause) {
+        pending.delete(id);
+        clearTimeout(timer);
+        reject(cause);
+      }
+    });
+  try {
+    await withinDeadline(
+      new Promise((resolve, reject) => {
+        socket.addEventListener("open", resolve, { once: true });
+        socket.addEventListener("error", reject, { once: true });
+        socket.addEventListener("close", reject, { once: true });
+      }),
+    );
+    const identity = await call("Runtime.evaluate", {
+      expression: "process.pid",
+      returnByValue: true,
+    });
+    assert.equal(identity.result.value, expectedPid);
+    const before = await call("Runtime.getHeapUsage");
+    await call("HeapProfiler.collectGarbage");
+    const after = await call("Runtime.getHeapUsage");
+    for (const sample of [before, after]) {
+      assert.ok(Number.isSafeInteger(sample.usedSize) && sample.usedSize >= 0);
+      assert.ok(Number.isSafeInteger(sample.totalSize));
+      assert.ok(sample.totalSize >= sample.usedSize);
+    }
+    return {
+      scope:
+        "Owned REA V8 heap after the complete SDK task; inspector and forced GC are diagnostic overhead",
+      pid_verified: true,
+      before_gc: before,
+      after_gc: after,
+    };
+  } finally {
+    rejectPending(new Error("Owned REA inspector diagnostic finished"));
+    socket.close();
+    await withinDeadline(closed);
+  }
+};

experiments/analysis-efficiency/mcp-startup-costs.py

@@ -3,6 +3,7 @@ import argparse
 import hashlib
 import importlib.util
 import json
+import math
 import statistics
 from pathlib import Path
 
@@ -32,7 +33,8 @@ spec.loader.exec_module(module)
 catalogs = {}
 identities = {}
 rows = []
-for case in inputs['cases']:
+heap_rows = []
+for case in inputs['cases'] + inputs.get('diagnostic_cases', []):
     directory = root / case['case']
     report = json.loads((directory / 'report.json').read_text())
     assert report['status'] == 'passed' and report['cleanup_verified']
@@ -41,6 +43,7 @@ for case in inputs['cases']:
     for name, producer_digest in report['producer_sources_sha256'].items():
         assert producer_digest == inputs['harness_sources_sha256'][name]
     assert report['runtime_binding'] == expected[case['role']]
+    assert type(report['elapsed_ms']) in [int, float] and math.isfinite(report['elapsed_ms']) and report['elapsed_ms'] >= 0
     for key in ['role', 'cache', 'profile', 'phase']:
         assert report[key] == case[key]
     raw = (directory / 'catalog.json').read_bytes()
@@ -82,6 +85,7 @@ for case in inputs['cases']:
         assert guard_digest == inputs['harness_sources_sha256'][name]
     del resource['guard_sources_sha256']
     row = {**case, 'runtime_binding_sha256': sha(compact(report['runtime_binding']).encode()), 'runtime_audit_ms': report['runtime_audit_ms'],
+           'sdk_task_elapsed_seconds': report['elapsed_ms'] / 1000,
            'catalog_sha256': catalog_digest, 'parent_evidence_id': report.get('parent_evidence_id'),
            'parent_semantic_sha256': report.get('parent_semantic_sha256'),
            'answer_sha256': sha(compact(report['answer']).encode()), 'tokens_estimated': tokens,
@@ -91,7 +95,19 @@ for case in inputs['cases']:
            **resource,
            'receipt_sha256': {name: sha((directory / name).read_bytes()) for name in ['report.json', 'catalog.json', 'server.json', 'transcript.json']}}
     assert row['catalog_sha256'] == row['receipt_sha256']['catalog.json'] == catalogs[profile]['sha256']
-    rows.append(row)
+    heap = report.get('diagnostic_heap')
+    if case.get('diagnostic_heap'):
+        assert case['phase'] == 'analysis' and case['cache'] == 'cold' and case['artifact'] == 'zellij'
+        assert heap is not None and heap['pid_verified'] is True
+        for sample in [heap['before_gc'], heap['after_gc']]:
+            assert type(sample['usedSize']) is int and sample['usedSize'] >= 0
+            assert type(sample['totalSize']) is int and sample['totalSize'] >= sample['usedSize']
+        row['heap_observation'] = heap
+        row['retained_v8_heap_bytes_after_gc'] = heap['after_gc']['usedSize']
+        heap_rows.append(row)
+    else:
+        assert heap is None, 'Diagnostic GC contaminated a normal task trial'
+        rows.append(row)
 assert len(rows) == 72
 summary = []
 for phase in ['discovery', 'analysis']:
@@ -104,7 +120,7 @@ for phase in ['discovery', 'analysis']:
                     assert len(selected) == 3
                     item[role] = {metric: {'median': statistics.median(row[metric] for row in selected),
                                            'min': min(row[metric] for row in selected), 'max': max(row[metric] for row in selected)}
-                                  for metric in ['wall_seconds', 'cpu_seconds', 'kernel_family_peak_bytes_including_page_cache']}
+                                  for metric in ['wall_seconds', 'cpu_seconds', 'kernel_family_peak_bytes_including_page_cache', 'sdk_task_elapsed_seconds']}
                     item[role]['tokens_estimated'] = [row['tokens_estimated']['whole_task'] for row in selected]
                 summary.append(item)
 result = {'status': 'passed', 'tokenizer': f'tiktoken=={tiktoken.__version__}/cl100k_base; estimates, not model usage',
@@ -113,6 +129,23 @@ result = {'status': 'passed', 'tokenizer': f'tiktoken=={tiktoken.__version__}/cl
           'cache_scope': 'Cold disables server Node compile cache. Warm enables a prepopulated role/profile-specific cache after one complete analysis priming run. Fresh server/client processes and HOME each trial. Driver compile cache disabled in both cohorts. Cache hit rate and OS page cache are unmeasured; source/runtime audits warm compiled-file pages before startup.',
           'resource_scope': 'Whole SDK driver, resource observer and owned REA process family. Includes before/after source-and-all-compiled-JS/JSON binding, SDK schema checks, extra validation calls, bundle export and independent oracle checking. Kernel cgroup peak includes file cache. Build/download/oracle preparation and cache priming excluded. Retained V8 heap and forced-GC diagnostics were not separately measured.',
           'measurement_inputs': inputs, 'catalogs': catalogs, 'summary': summary, 'records': rows,
+          'sdk_task_elapsed_scope': 'SDK span from client connect through task checks and client/server close. Excludes pre/post runtime binding and preflight artifact/oracle loading. Diagnostic spans include inspector and forced GC. CPU is measured for the whole family only; per-span CPU is unmeasured.',
           'warmup_receipts': {name: sha((root / name / 'report.json').read_bytes()) for name in [f'warmup-{profile}-{role}' for profile in ['default', 'full'] for role in ['baseline', 'candidate']]}}
+if heap_rows:
+    assert len(heap_rows) == 12
+    heap_summary = []
+    for profile in ['default', 'full']:
+        item = {'profile': profile}
+        for role in ['baseline', 'candidate']:
+            selected = [row for row in heap_rows if row['profile'] == profile and row['role'] == role]
+            assert len(selected) == 3
+            item[role] = {metric: {'median': statistics.median(row[metric] for row in selected),
+                                   'min': min(row[metric] for row in selected), 'max': max(row[metric] for row in selected)}
+                          for metric in ['retained_v8_heap_bytes_after_gc', 'wall_seconds', 'cpu_seconds', 'sdk_task_elapsed_seconds',
+                                         'kernel_family_peak_bytes_including_page_cache']}
+        heap_summary.append(item)
+    result['heap_diagnostics'] = {
+        'scope': 'Separate three-pair Zellij tasks per profile, with an explicitly launched loopback inspector. Four CDP calls verify the owned REA PID, read heap, force GC and read heap again after the completed SDK task. These whole-family costs include inspector and diagnostic GC overhead; they are excluded from the normal timing cohort. Heap values describe REA V8 only, not the client or the whole process family.',
+        'summary': heap_summary, 'records': heap_rows}
 args.output.write_text(json.dumps(result, indent=2) + '\n')
 print(json.dumps(summary, indent=2))

src/android/JadxProtocol.ts

@@ -4,14 +4,14 @@ import { jsonValueSchema } from "../domain/jsonValue.js";
 import type { AndroidOperation } from "../domain/android/androidAnalysis.js";
 import { dexDescriptorSchema } from "../domain/android/androidAnalysis.js";
 
-const count = z.number().int().nonnegative();
+const count = z.int().nonnegative();
 /** Typed allocation failures authored before upstream erases the JVM exception. */
 const jadxMemoryFailureSchema = z.strictObject({
   kind: z.literal("jvm-memory-failure"),
   memory_area: z.enum(["heap", "unknown"]),
   exception_type: z.literal("java.lang.OutOfMemoryError"),
   message: z.string().optional(),
-  max_heap_bytes: z.number().int().positive().safe(),
+  max_heap_bytes: z.int().positive().safe(),
 });
 /** Selector failures authored by REA's bridge, separate from arbitrary engine errors. */
 const jadxInputFailureSchema = z.strictObject({
@@ -40,8 +40,8 @@ export const parseJadxFailure = (
 /** Values observed inside the exact JVM producing the analysis. */
 export const jadxRuntimeSchema = z.object({
   engine_reported_version: z.string().min(1),
-  max_heap_bytes: z.number().int().positive().safe(),
-  available_processors: z.number().int().positive(),
+  max_heap_bytes: z.int().positive().safe(),
+  available_processors: z.int().positive(),
   java_version: z.string().min(1),
   metadata_scope: z.literal("parsed_members"),
 });
@@ -81,11 +81,11 @@ export const jadxClassSchema = z.object({
       signature: z.string(),
       dex_descriptor: dexDescriptorSchema,
       is_constructor: z.boolean(),
-      def_pos: z.number().int(),
+      def_pos: z.int(),
     }),
   ),
   fields: z.array(
-    z.object({ name: z.string(), type: z.string(), def_pos: z.number().int() }),
+    z.object({ name: z.string(), type: z.string(), def_pos: z.int() }),
   ),
   inner_classes: z.array(z.string()),
 });
@@ -115,7 +115,7 @@ export const jadxXrefsSchema = z.object({
       full_name: z.string(),
       containing_class: z.string(),
       top_class: z.string(),
-      def_pos: z.number().int(),
+      def_pos: z.int(),
       direct_invokes_exhaustive: z.boolean().optional(),
       direct_invokes: z
         .array(

src/browser/PlaywrightElectronActiveActions.ts

@@ -33,7 +33,7 @@ const hookSnapshotSchema = z.strictObject({
   dropped_runtime: retention.dropped_runtime,
   dropped_event_families: retention.dropped_event_families,
   dropped_event_roles: retention.dropped_event_roles,
-  observed: z.number().int().min(0),
+  observed: z.int().min(0),
   observed_ipc: retention.observed_ipc,
   observed_runtime: retention.observed_runtime,
   hook_error: z.boolean(),

src/browser/PlaywrightScenarioArtifacts.ts

@@ -11,7 +11,7 @@ import {
 import type { BrowserScenarioSecrets } from "./BrowserScenarioSecrets.js";
 
 const historyValueSchema = z.strictObject({
-  length: z.number().int().min(0),
+  length: z.int().min(0),
   navigation_entries: z.array(
     z.strictObject({
       type: z.string(),

src/browser/execution/CdpEventListeners.ts

@@ -24,10 +24,10 @@ export const captureWebEventListeners = async (
       await session.enable(domain);
     await session.assertDocument();
     const document = z
-      .object({ root: z.object({ nodeId: z.number().int().min(1) }) })
+      .object({ root: z.object({ nodeId: z.int().min(1) }) })
       .parse(await session.command("DOM.getDocument", { depth: 0 }));
     const selected = z
-      .object({ nodeId: z.number().int().min(0) })
+      .object({ nodeId: z.int().min(0) })
       .parse(
         await queryListenerSelector(
           session,
@@ -39,7 +39,7 @@ export const captureWebEventListeners = async (
     let descriptors: z.infer<typeof runtimeListenersSchema>["listeners"] = [];
     if (selected.nodeId !== 0) {
       const described = z
-        .object({ node: z.object({ backendNodeId: z.number().int().min(1) }) })
+        .object({ node: z.object({ backendNodeId: z.int().min(1) }) })
         .parse(
           await session.command("DOM.describeNode", {
             nodeId: selected.nodeId,

src/browser/execution/CdpRuntimeProtocol.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-const integer = z.number().int().min(0);
+const integer = z.int().min(0);
 const contextAuxDataSchema = z
   .object({
     frameId: z.string().optional(),

src/config/mcpResponseBudget.ts

@@ -37,7 +37,7 @@ export const mcpResponseBudgetSchema = z
   .string()
   .regex(/^[1-9]\d*$/u)
   .transform(Number)
-  .pipe(z.number().int().safe().min(MINIMUM_RESPONSE_BYTES));
+  .pipe(z.int().safe().min(MINIMUM_RESPONSE_BYTES));
 
 const budgetConstraint = `REA_MCP_MAX_RESPONSE_BYTES must be a decimal safe integer at least ${String(MINIMUM_RESPONSE_BYTES)} bytes, the default stdio receive-buffer size.`;
 

src/config/providerStartupTimeout.ts

@@ -21,4 +21,4 @@ export const providerStartupTimeoutSchema = z
   .string()
   .regex(/^[1-9]\d*$/u, "must be a positive decimal integer")
   .transform(Number)
-  .pipe(z.number().int().min(1).max(MAX_PROVIDER_STARTUP_TIMEOUT_MS));
+  .pipe(z.int().min(1).max(MAX_PROVIDER_STARTUP_TIMEOUT_MS));

src/contracts/artifactToolContracts.ts

@@ -92,9 +92,9 @@ export const ARTIFACT_TOOL_CONTRACTS = [
     "decode_interface_builder",
     "Decode compiled storyboard and nib archives inside the active Apple app bundle, including keyed property lists and NIBArchive object tables, into a bounded object, hierarchy, and connection graph. This is static archive parsing; unrecognized archive classes and unresolved code handlers remain explicit unknowns. A full app graph is often several megabytes; detail summary retains it and returns documents with node, edge and coverage counts, then page rows, optionally one document's, with inspect_analysis_view kind interface-builder.",
     z.strictObject({
-      max_documents: z.number().int().min(1).max(64).default(64),
-      max_objects: z.number().int().min(1).max(20_000).default(20_000),
-      max_connections: z.number().int().min(1).max(40_000).default(40_000),
+      max_documents: z.int().min(1).max(64).default(64),
+      max_objects: z.int().min(1).max(20_000).default(20_000),
+      max_connections: z.int().min(1).max(40_000).default(40_000),
       detail: analysisDetailSchema
         .unwrap()
         .optional()

src/contracts/cutterToolContracts.ts

@@ -10,7 +10,7 @@ export const cutterListInputSchema = z.strictObject({});
 /** Execute a command in a selected live Cutter instance and observed document generation. */
 export const cutterCommandInputSchema = z.strictObject({
   session_id: z.string().uuid(),
-  expected_generation: z.number().int().nonnegative(),
+  expected_generation: z.int().nonnegative(),
   command: z
     .string()
     .min(1)
@@ -23,8 +23,8 @@ export const cutterCommandInputSchema = z.strictObject({
 
 export const cutterSessionSchema = z.strictObject({
   session_id: z.string().uuid(),
-  pid: z.number().int().positive(),
-  document_generation: z.number().int().nonnegative(),
+  pid: z.int().positive(),
+  document_generation: z.int().nonnegative(),
   current_file: z.string().nullable(),
   cutter_version: z.string().nullable(),
   identity_status: z.literal("partial"),
@@ -39,7 +39,7 @@ export const cutterCommandResultSchema = z.strictObject({
   output_truncated: z.boolean(),
   cutter_version: z.string().nullable(),
   current_file: z.string().nullable(),
-  document_generation: z.number().int().nonnegative(),
+  document_generation: z.int().nonnegative(),
   identity_status: z.literal("partial"),
 });
 

src/contracts/enhancedInputs.ts

@@ -19,12 +19,7 @@ export type CallRelationshipDirection = z.output<
 export const enhancedInputSchemas = {
   trace_native_values: nativeValueTraceInputSchema,
   inspect_native_dispatch_metadata: z.strictObject({
-    max_records: z
-      .number()
-      .int()
-      .min(1)
-      .max(MAX_ENHANCED_RECORDS)
-      .default(5_000),
+    max_records: z.int().min(1).max(MAX_ENHANCED_RECORDS).default(5_000),
     objc_class_import_addresses: z
       .array(z.string())
       .max(MAX_ENHANCED_RECORDS)
@@ -101,9 +96,9 @@ export const enhancedInputSchemas = {
       .describe(
         "A unique compiled UI action selector, interface object ID, native symbol or exact function address",
       ),
-    max_depth: z.number().int().min(0).max(32).default(8),
-    max_nodes: z.number().int().min(1).max(2_000).default(250),
-    max_edges: z.number().int().min(1).max(5_000).default(500),
+    max_depth: z.int().min(0).max(32).default(8),
+    max_nodes: z.int().min(1).max(2_000).default(250),
+    max_edges: z.int().min(1).max(5_000).default(500),
   }),
 } as const;
 

src/contracts/fridaToolContracts.ts

@@ -24,7 +24,6 @@ const remoteConnection = z.strictObject({
   certificate: z.string().min(1).optional(),
   origin: z.string().min(1).optional(),
   keepalive_interval: z
-    .number()
     .int()
     .positive()
     .describe(FRIDA_KEEPALIVE_INTERVAL_DESCRIPTION)
@@ -100,7 +99,7 @@ export const FRIDA_TOOL_CONTRACTS = [
       device_id: z.string(),
       processes: z.array(
         z.strictObject({
-          pid: z.number().int().nonnegative(),
+          pid: z.int().nonnegative(),
           name: z.string(),
           identifier: z.string().nullable(),
         }),
@@ -124,7 +123,7 @@ export const FRIDA_TOOL_CONTRACTS = [
       .strictObject({
         mode: z.enum(["attach", "spawn"]),
         ...deviceSelector.shape,
-        pid: z.number().int().positive().optional(),
+        pid: z.int().positive().optional(),
         program: localPathStringSchema.optional(),
         argv: z.array(z.string()).optional(),
       })
@@ -262,13 +261,13 @@ export const FRIDA_TOOL_CONTRACTS = [
       .strictObject({
         mode: z.enum(["attach", "spawn"]),
         ...deviceSelector.shape,
-        pid: z.number().int().positive().optional(),
+        pid: z.int().positive().optional(),
         program: localPathStringSchema.optional(),
         argv: z.array(z.string()).optional(),
         source_kind: z.enum(["inline", "file"]),
         source: z.string().optional(),
         path: localPathStringSchema.optional(),
-        duration_ms: z.number().int().min(0).max(60_000).default(1_000),
+        duration_ms: z.int().min(0).max(60_000).default(1_000),
       })
       .refine(
         (value) =>

src/contracts/gdbToolContracts.ts

@@ -73,7 +73,7 @@ export const GDB_TOOL_CONTRACTS = [
       recent_mi_records_truncated: z.boolean(),
       mi_invalid_utf8: z.boolean(),
       stderr: z.string(),
-      stderr_observed_bytes: z.number().int().nonnegative(),
+      stderr_observed_bytes: z.int().nonnegative(),
       stderr_truncated: z.boolean(),
       stderr_invalid_utf8: z.boolean(),
       diagnostics_truncated: z.boolean(),

src/contracts/hopperMemoryContracts.ts

@@ -17,7 +17,7 @@ export const HOPPER_MEMORY_TOOL_DEFINITIONS = [
         document,
         start: address.optional(),
         end: address.optional(),
-        limit: z.number().int().min(1).max(1000).default(100),
+        limit: z.int().min(1).max(1000).default(100),
         cursor: z.string().min(1).optional(),
       })
       .superRefine(validateBytePattern),
@@ -28,7 +28,7 @@ export const HOPPER_MEMORY_TOOL_DEFINITIONS = [
       "Read analyzed bytes from one provider-normalized virtual address. The hexadecimal payload reports the exact returned length; incomplete reads remain explicit and unsupported provider APIs return typed capability unavailability.",
     inputSchema: z.object({
       address,
-      length: z.number().int().min(1).default(256),
+      length: z.int().min(1).default(256),
       document,
     }),
   },

src/contracts/sessionToolSchemas.ts

@@ -48,7 +48,7 @@ export const processComparisonInputSchema = z.strictObject({
   left: evidenceSchema,
   right: evidenceSchema,
   trace_spec: processTraceSpecificationSchema.optional(),
-  max_capture_age_ms: z.number().int().nonnegative().optional(),
+  max_capture_age_ms: z.int().nonnegative().optional(),
 });
 
 /** Residual-unknown list filters. */
@@ -59,14 +59,12 @@ export const listUnknownsInputSchema = z.strictObject({
   severity: z.enum(["low", "medium", "high", "critical"]).optional(),
   domain: z.string().trim().min(1).optional(),
   offset: z
-    .number()
     .int()
     .min(0)
     .max(Number.MAX_SAFE_INTEGER)
     .default(0)
     .describe("Zero-based offset in the stable filtered unknown ID order."),
   limit: z
-    .number()
     .int()
     .positive()
     .max(Number.MAX_SAFE_INTEGER)

src/contracts/toolOutputSchemaGroups.ts

@@ -167,9 +167,8 @@ export const officialOutputSchemas: Readonly<Record<string, z.ZodObject>> = {
   address_to_file_offset: evidenceResultOf(
     z.object({
       address: z.string(),
-      file_offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+      file_offset: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
       provider_file_offset: z
-        .number()
         .int()
         .min(0)
         .max(Number.MAX_SAFE_INTEGER)
@@ -178,7 +177,6 @@ export const officialOutputSchemas: Readonly<Record<string, z.ZodObject>> = {
           "Original coordinate returned by the provider's mapping API.",
         ),
       image_base_file_offset: z
-        .number()
         .int()
         .min(0)
         .max(Number.MAX_SAFE_INTEGER)
@@ -259,14 +257,14 @@ const callPathTraceOutput = evidenceResultOf(
     nodes: z.array(
       z.object({
         address: z.string(),
-        depth: z.number().int().min(0),
+        depth: z.int().min(0),
       }),
     ),
     edges: z.array(
       z.object({
         source_address: z.string(),
         target_address: z.string(),
-        discovery_depth: z.number().int().min(1),
+        discovery_depth: z.int().min(1),
       }),
     ),
     traversal_path: z.array(z.string()),
@@ -278,7 +276,7 @@ const callPathTraceOutput = evidenceResultOf(
     ),
     relationship_coverage: z.record(z.string(), relationshipCoverageSchema),
     traversal: z.object({
-      nodes_visited: z.number().int().min(1),
+      nodes_visited: z.int().min(1),
     }),
     truncated: z.boolean(),
     residual_unknowns: z.array(z.string()),
@@ -334,9 +332,9 @@ export const enhancedOutputSchemas: Readonly<Record<string, z.ZodObject>> = {
           }),
         ]),
       ),
-      total: z.number().int().min(0),
-      succeeded: z.number().int().min(0),
-      failed: z.number().int().min(0),
+      total: z.int().min(0),
+      succeeded: z.int().min(0),
+      failed: z.int().min(0),
     }),
   ),
   get_call_graph: evidenceResultOf(
@@ -347,11 +345,11 @@ export const enhancedOutputSchemas: Readonly<Record<string, z.ZodObject>> = {
   ),
   analyze_swift_types: evidenceResultOf(
     z.object({
-      total: z.number().int().min(0),
+      total: z.int().min(0),
       categories: z.record(
         z.string(),
         z.object({
-          count: z.number().int().min(0),
+          count: z.int().min(0),
           items: z.array(
             addressedEntry.extend({
               mangled_names: z.array(z.string()),
@@ -400,9 +398,9 @@ export const enhancedOutputSchemas: Readonly<Record<string, z.ZodObject>> = {
           }),
         )
         .optional(),
-      segment_count: z.number().int().min(0).optional(),
-      procedure_count: z.number().int().min(0),
-      string_count: z.number().int().min(0),
+      segment_count: z.int().min(0).optional(),
+      procedure_count: z.int().min(0),
+      string_count: z.int().min(0),
     }),
   ),
   analyze_function: functionDossierOutput,
@@ -519,19 +517,16 @@ export const sessionOutputSchemas = {
       z.null(),
       z.object({
         path: z.string(),
-        bytes: z.number().int().min(0),
+        bytes: z.int().min(0),
         primitive_entries: z
-          .number()
           .int()
           .min(0)
           .describe("Retained eligible primitive query bindings."),
         workflow_entries: z
-          .number()
           .int()
           .min(0)
           .describe("Retained eligible composed workflow bindings."),
         evidence_records: z
-          .number()
           .int()
           .min(0)
           .describe(
@@ -561,9 +556,9 @@ export const sessionOutputSchemas = {
   export_evidence_bundle: lifecycleResultOf(
     z.object({
       path: z.string(),
-      bytes: z.number().int().min(0),
-      records: z.number().int().min(0),
-      unknowns: z.number().int().min(0),
+      bytes: z.int().min(0),
+      records: z.int().min(0),
+      unknowns: z.int().min(0),
     }),
   ),
   get_evidence_bundle: lifecycleResultOf(
@@ -589,9 +584,9 @@ export const sessionOutputSchemas = {
   ),
   import_evidence_bundle: lifecycleResultOf(
     z.object({
-      imported: z.number().int().min(0),
-      unknowns_added: z.number().int().min(0),
-      total: z.number().int().min(0),
+      imported: z.int().min(0),
+      unknowns_added: z.int().min(0),
+      total: z.int().min(0),
     }),
   ),
   capture_process_scenario: evidenceResultOf(processCaptureSchema),
@@ -616,9 +611,9 @@ export const sessionOutputSchemas = {
   list_unknowns: lifecycleResultOf(
     z.object({
       items: z.array(residualUnknownSchema),
-      total: z.number().int().min(0),
-      offset: z.number().int().min(0),
-      next_offset: z.number().int().min(0).nullable(),
+      total: z.int().min(0),
+      offset: z.int().min(0),
+      next_offset: z.int().min(0).nullable(),
     }),
   ),
   record_unknown: lifecycleResultOf(residualUnknownSchema),

src/contracts/toolOutputSchemaPrimitives.ts

@@ -174,8 +174,8 @@ export const expandProviderCapabilities = (
   );
 
 const processCoordinates = {
-  launcher_pid: z.number().int().min(1),
-  process_group_id: z.number().int().min(1),
+  launcher_pid: z.int().min(1),
+  process_group_id: z.int().min(1),
 };
 
 const processLineageObservation = z.discriminatedUnion("status", [
@@ -189,12 +189,12 @@ const processLineageObservation = z.discriminatedUnion("status", [
     status: z.literal("verified"),
     observed_at: z.iso.datetime(),
     ...processCoordinates,
-    launcher_parent_pid: z.number().int().min(0),
+    launcher_parent_pid: z.int().min(0),
     descendants: z.array(
       z.object({
-        pid: z.number().int().min(1),
-        parent_pid: z.number().int().min(0),
-        process_group_id: z.number().int().min(1),
+        pid: z.int().min(1),
+        parent_pid: z.int().min(0),
+        process_group_id: z.int().min(1),
       }),
     ),
   }),
@@ -225,19 +225,19 @@ export const analysisActivity = z.object({
       provider: providerIdentity,
       active: z
         .object({
-          request_id: z.number().int().min(1),
+          request_id: z.int().min(1),
           operation: z.string().min(1),
-          elapsed_ms: z.number().int().min(0),
+          elapsed_ms: z.int().min(0),
           caller_state: z.enum(["waiting", "cancelled"]),
         })
         .nullable(),
-      queued_requests: z.number().int().min(0),
+      queued_requests: z.int().min(0),
     }),
   ),
 });
 
 const providerOperationRequest = z.object({
-  request_id: z.number().int().min(1),
+  request_id: z.int().min(1),
   operation: z.string().min(1),
   stage: z.enum(PROVIDER_FAILURE_STAGES),
 });
@@ -247,7 +247,7 @@ export const providerOperationHealth = z
     state: z.enum(PROVIDER_OPERATION_STATES),
     stage: z.enum(PROVIDER_FAILURE_STAGES).nullable(),
     retry_action: z.enum(PROVIDER_RETRY_ACTIONS).nullable(),
-    exit_code: z.number().int().nullable(),
+    exit_code: z.int().nullable(),
     requests: z.array(providerOperationRequest),
   })
   .nullable();
@@ -524,9 +524,9 @@ export const sessionProvider = z
       skill: z.object({ name: z.string(), expected_version: z.string() }),
       catalog: z.strictObject({
         counts: z.strictObject({
-          cli_commands: z.number().int().min(0),
-          mcp_tools: z.number().int().min(0),
-          mcp_prompts: z.number().int().min(0),
+          cli_commands: z.int().min(0),
+          mcp_tools: z.int().min(0),
+          mcp_prompts: z.int().min(0),
         }),
         digests: z.strictObject({
           tools_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
@@ -602,14 +602,14 @@ export const procedureInfoOutput = evidenceResultOf(procedureInfoSchema);
 export const symbolDiscoveryOutput = (property: "classes" | "protocols") =>
   evidenceResultOf(
     z.object({
-      count: z.number().int().min(0),
+      count: z.int().min(0),
       [property]: z.array(addressedEntry),
     }),
   );
 
 export const objcClassDiscoveryOutput = evidenceResultOf(
   z.object({
-    count: z.number().int().min(0),
+    count: z.int().min(0),
     classes: z.array(
       addressedEntry.extend({
         binding_identity: objcClassImportIdentitySchema

src/contracts/wasm/wasmComparisonContracts.ts

@@ -23,7 +23,7 @@ const identity = z.object({
   artifact: z.object({
     path: z.string(),
     sha256: z.string(),
-    bytes: z.number().int().nonnegative(),
+    bytes: z.int().nonnegative(),
   }),
 });
 export const wasmInterfaceComparisonSchema = z.object({

src/cutter/CutterBridgeClient.ts

@@ -31,11 +31,11 @@ import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 
 const descriptorSchema = z.object({
   session_id: z.string().uuid(),
-  pid: z.number().int().positive(),
+  pid: z.int().positive(),
   host: z.literal("127.0.0.1"),
-  port: z.number().int().min(1).max(65535),
+  port: z.int().min(1).max(65535),
   token: z.string().min(20),
-  document_generation: z.number().int().nonnegative(),
+  document_generation: z.int().nonnegative(),
   current_file: z.string().nullable(),
   cutter_version: z.string().nullable(),
   identity_status: z.literal("partial"),
@@ -53,7 +53,7 @@ const responseSchema = z.object({
   output: z.unknown().optional(),
   current_file: z.string().nullable().optional(),
   cutter_version: z.string().nullable().optional(),
-  document_generation: z.number().int().nonnegative().optional(),
+  document_generation: z.int().nonnegative().optional(),
   identity_status: z.literal("partial").optional(),
   error: z.string().optional(),
   message: z.string().optional(),

src/domain/adb/adbDeviceAnalysis.ts

@@ -139,7 +139,6 @@ export const adbInputSchemas = {
       "Device serial exactly as `adb devices` reports it",
     ),
     count: z
-      .number()
       .int()
       .min(1)
       .max(10_000)
@@ -150,7 +149,6 @@ export const adbInputSchemas = {
       .default("main")
       .describe("Log buffer to read (logcat -b)"),
     pid: z
-      .number()
       .int()
       .positive()
       .optional()
@@ -466,7 +464,7 @@ const device = z.strictObject({
   product: z.string().nullable(),
   model: z.string().nullable(),
   device: z.string().nullable(),
-  transport_id: z.number().int().positive().nullable(),
+  transport_id: z.int().positive().nullable(),
   /**
    * Inferred device kind with its evidence basis. The serial prefix and the
    * `device:` metadata line are observations; the kind itself is derived.
@@ -479,7 +477,7 @@ const pulledArtifact = z.strictObject({
   device_path: z.string().min(1),
   file_name: z.string().min(1),
   local_path: z.string().min(1),
-  bytes: z.number().int().nonnegative(),
+  bytes: z.int().nonnegative(),
   sha256: z.string().regex(/^[a-f0-9]{64}$/u),
   role: z.enum(["base", "split", "unknown"]),
   role_basis: z.literal("file_name"),
@@ -531,7 +529,7 @@ export const adbResultSchemas = {
     properties: z.array(
       z.strictObject({ name: z.string().min(1), value: z.string().min(1) }),
     ),
-    property_count: z.number().int().nonnegative(),
+    property_count: z.int().nonnegative(),
     emulator_observed: z.boolean().nullable(),
   }),
   list_adb_packages: z.strictObject({
@@ -560,11 +558,11 @@ export const adbResultSchemas = {
   read_adb_logcat: z.strictObject({
     client,
     serial: z.string().min(1),
-    count: z.number().int().positive(),
+    count: z.int().positive(),
     buffer: z.enum(["main", "system", "radio", "events", "crash"]),
-    pid: z.number().int().positive().nullable(),
+    pid: z.int().positive().nullable(),
     lines: z.array(z.string()),
-    total_bytes: z.number().int().nonnegative(),
+    total_bytes: z.int().nonnegative(),
     coverage: z.enum(["complete", "partial"]),
   }),
   inspect_adb_package: z.strictObject({
@@ -582,9 +580,9 @@ export const adbResultSchemas = {
     first_install_time: z.string().nullable(),
     last_update_time: z.string().nullable(),
     installer_package_name: z.string().nullable(),
-    user_id: z.number().int().nullable(),
+    user_id: z.int().nullable(),
     pkg_flags: z.string().nullable(),
-    requested_permissions_count: z.number().int().nonnegative().nullable(),
+    requested_permissions_count: z.int().nonnegative().nullable(),
     coverage: z.enum(["complete", "partial"]),
   }),
   pull_adb_file: z.strictObject({
@@ -592,7 +590,7 @@ export const adbResultSchemas = {
     serial: z.string().min(1),
     device_path: z.string().min(1),
     local_path: z.string().min(1),
-    bytes: z.number().int().nonnegative(),
+    bytes: z.int().nonnegative(),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
   }),
   push_adb_file: z.strictObject({
@@ -600,7 +598,7 @@ export const adbResultSchemas = {
     serial: z.string().min(1),
     local_path: z.string().min(1),
     device_path: z.string().min(1),
-    bytes: z.number().int().nonnegative(),
+    bytes: z.int().nonnegative(),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     device_sha256: z
       .string()
@@ -613,10 +611,10 @@ export const adbResultSchemas = {
     client,
     serial: z.string().min(1),
     local_path: z.string().min(1),
-    bytes: z.number().int().nonnegative(),
+    bytes: z.int().nonnegative(),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    width: z.number().int().positive().nullable(),
-    height: z.number().int().positive().nullable(),
+    width: z.int().positive().nullable(),
+    height: z.int().positive().nullable(),
   }),
   list_adb_processes: z.strictObject({
     client,
@@ -625,9 +623,9 @@ export const adbResultSchemas = {
     processes: z.array(
       z.strictObject({
         user: z.string(),
-        pid: z.number().int().nonnegative(),
-        ppid: z.number().int().nullable(),
-        rss: z.number().int().nullable(),
+        pid: z.int().nonnegative(),
+        ppid: z.int().nullable(),
+        rss: z.int().nullable(),
         state: z.string().nullable(),
         name: z.string(),
       }),
@@ -646,7 +644,7 @@ export const adbResultSchemas = {
         permissions: z.string().nullable(),
         owner: z.string().nullable(),
         group: z.string().nullable(),
-        bytes: z.number().int().nullable(),
+        bytes: z.int().nullable(),
         date: z.string().nullable(),
         link_target: z.string().nullable(),
       }),
@@ -660,7 +658,7 @@ export const adbResultSchemas = {
     features: z.array(
       z.strictObject({
         name: z.string().min(1),
-        version: z.number().int().nullable(),
+        version: z.int().nullable(),
       }),
     ),
     unparsed_lines: z.array(z.string().min(1)),
@@ -682,17 +680,17 @@ export const adbResultSchemas = {
     client,
     serial: z.string().min(1),
     physical_size: z.strictObject({
-      width: z.number().int().positive(),
-      height: z.number().int().positive(),
+      width: z.int().positive(),
+      height: z.int().positive(),
     }),
     override_size: z
       .strictObject({
-        width: z.number().int().positive(),
-        height: z.number().int().positive(),
+        width: z.int().positive(),
+        height: z.int().positive(),
       })
       .nullable(),
-    physical_density: z.number().int().positive().nullable(),
-    override_density: z.number().int().positive().nullable(),
+    physical_density: z.int().positive().nullable(),
+    override_density: z.int().positive().nullable(),
   }),
   inspect_adb_window: z.strictObject({
     client,
@@ -716,7 +714,7 @@ export const adbResultSchemas = {
     client,
     serial: z.string().min(1),
     local_path: z.string().min(1),
-    bytes: z.number().int().nonnegative(),
+    bytes: z.int().nonnegative(),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     adb_reported_path: z.string().nullable(),
   }),
@@ -738,7 +736,7 @@ export const adbResultSchemas = {
     client,
     serial: z.string().min(1),
     apk_path: z.string().min(1),
-    bytes: z.number().int().nonnegative(),
+    bytes: z.int().nonnegative(),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     replace_requested: z.boolean(),
     replaced: z.boolean().nullable(),

src/domain/analysisView/analysisView.ts

@@ -226,7 +226,7 @@ const facetViewSchema = z.strictObject({
   facet: z.enum(["mitigations", "linkage"]),
 });
 const indexSelectorSchema = z.strictObject({
-  index: z.number().int().nonnegative(),
+  index: z.int().nonnegative(),
 });
 const nameSelectorSchema = z.strictObject({ name: z.string() });
 const pathSelectorSchema = z.strictObject({
@@ -264,8 +264,8 @@ const itemViewSchema = z.discriminatedUnion("collection", [
 const pageViewSchema = z.strictObject({
   kind: z.literal("page"),
   collection: z.enum(["sections", "symbols", "modules"]),
-  offset: z.number().int().nonnegative(),
-  limit: z.number().int().positive(),
+  offset: z.int().nonnegative(),
+  limit: z.int().positive(),
 });
 
 /** Bounded native function facets of already authenticated analyze_function Evidence. */
@@ -294,8 +294,8 @@ const nativeViewSchema = z.strictObject({
     "value_flow_parameters",
     "value_flow_parameter_uses",
   ]),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 /** Caller-selected projection of already completed analysis Evidence. */
@@ -367,9 +367,9 @@ export const inspectAnalysisViewInputSchema = z.strictObject({
 
 const coverageSchema = z.strictObject({
   status: z.enum(["complete-within-view", "page", "empty"]),
-  examined: z.number().int().nonnegative(),
-  total: z.number().int().nonnegative(),
-  next_offset: z.number().int().nonnegative().nullable(),
+  examined: z.int().nonnegative(),
+  total: z.int().nonnegative(),
+  next_offset: z.int().nonnegative().nullable(),
   exhausted: z.boolean(),
 });
 
@@ -393,12 +393,12 @@ const layoutSummarySchema = z.strictObject({
     execution_status: z.literal("unknown"),
   }),
   counts: z.strictObject({
-    sections: z.number().int().nonnegative(),
-    segments: z.number().int().nonnegative(),
-    symbols: z.number().int().nonnegative(),
-    relocations: z.number().int().nonnegative(),
+    sections: z.int().nonnegative(),
+    segments: z.int().nonnegative(),
+    symbols: z.int().nonnegative(),
+    relocations: z.int().nonnegative(),
   }),
-  limitation_count: z.number().int().nonnegative(),
+  limitation_count: z.int().nonnegative(),
 });
 
 const javascriptSummarySchema = z.strictObject({
@@ -409,7 +409,7 @@ const javascriptSummarySchema = z.strictObject({
   statistics: jsonObjectSchema,
   electron: jsonObjectSchema,
   coverage: jsonObjectSchema,
-  limitation_count: z.number().int().nonnegative(),
+  limitation_count: z.int().nonnegative(),
 });
 
 const viewResultBase = {

src/domain/analysisView/androidPackageView.ts

@@ -17,7 +17,7 @@ const packageSchema = androidResultSchemas.inspect_android_package;
 /** All package declarations remain inline; decoded manifest text stays retained. */
 export const androidPackageSummarySchema = packageSchema.extend({
   manifest: packageSchema.shape.manifest.omit({ text: true }).extend({
-    text_code_units: z.number().int().nonnegative(),
+    text_code_units: z.int().nonnegative(),
     text_included: z.literal(false),
   }),
 });
@@ -26,8 +26,8 @@ export const androidPackageSummarySchema = packageSchema.extend({
 export const androidViewRequestSchema = z.strictObject({
   kind: z.literal("android"),
   facet: z.literal("manifest"),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive(),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive(),
 });
 
 export const androidManifestViewItemSchema = z.strictObject({

src/domain/analysisView/dartAotView.ts

@@ -22,9 +22,9 @@ export const dartAotSummarySchema = aotSchema.extend({
     .omit({ package_uris: true, dart_uris: true, class_like_tokens: true })
     .extend({
       returned_counts: z.strictObject({
-        package_uris: z.number().int().nonnegative(),
-        dart_uris: z.number().int().nonnegative(),
-        class_like_tokens: z.number().int().nonnegative(),
+        package_uris: z.int().nonnegative(),
+        dart_uris: z.int().nonnegative(),
+        class_like_tokens: z.int().nonnegative(),
       }),
     }),
 });
@@ -33,8 +33,8 @@ export const dartAotSummarySchema = aotSchema.extend({
 export const dartAotViewRequestSchema = z.strictObject({
   kind: z.literal("dart-aot"),
   collection: z.enum(["package_uris", "dart_uris", "class_like_tokens"]),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 export const dartAotViewContextSchema = z.strictObject({

src/domain/analysisView/evmInterfaceView.ts

@@ -20,8 +20,8 @@ import { analysisTextPage } from "./analysisViewText.js";
 export const evmViewRequestSchema = z.strictObject({
   kind: z.literal("evm"),
   facet: z.enum(["functions", "bytecode_hex", "stdout", "stderr"]),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 export const evmViewItemSchema = z.union([
@@ -40,7 +40,7 @@ export const evmSummarySchema = z.strictObject({
   diagnostics: evmInterfaceSchema.shape.diagnostics
     .omit({ stdout: true })
     .extend({
-      stdout_code_units: z.number().int().nonnegative(),
+      stdout_code_units: z.int().nonnegative(),
     }),
   limitations: evmInterfaceSchema.shape.limitations,
 });

src/domain/analysisView/interfaceBuilderView.ts

@@ -28,8 +28,8 @@ import {
 
 const page = {
   kind: z.literal("interface-builder"),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 } as const;
 
 /** Original decoded rows; graph rows can be narrowed to one decoded document. */
@@ -66,7 +66,7 @@ export const interfaceBuilderViewContextSchema = z.strictObject({
   source_truncated: z.boolean(),
 });
 
-const countsSchema = z.record(z.string(), z.number().int().positive());
+const countsSchema = z.record(z.string(), z.int().positive());
 
 /** Every decoded document with graph counts; rows and evidence stay retained. */
 export const interfaceBuilderSummarySchema = z.strictObject({
@@ -77,15 +77,15 @@ export const interfaceBuilderSummarySchema = z.strictObject({
   provider: nativeInvestigationProviderSchema,
   documents: interfaceBuilderDocumentSchema.array().max(64),
   available_counts: z.strictObject({
-    nodes: z.number().int().nonnegative(),
-    edges: z.number().int().nonnegative(),
-    coverage: z.number().int().nonnegative(),
+    nodes: z.int().nonnegative(),
+    edges: z.int().nonnegative(),
+    coverage: z.int().nonnegative(),
   }),
   node_kinds: countsSchema,
   edge_relations: countsSchema,
   coverage_statuses: countsSchema,
   truncated: z.boolean(),
-  limitation_count: z.number().int().nonnegative(),
+  limitation_count: z.int().nonnegative(),
 });
 
 const tally = (values: readonly string[]): Record<string, number> => {

src/domain/analysisView/javascriptApplicationCoverage.ts

@@ -11,8 +11,8 @@ export const javascriptApplicationSourceCoverageSchema = z.strictObject({
   semantic: javaScriptSemanticGraphInputSchema.shape.coverage.omit({
     families: true,
   }),
-  application_unknown_count: z.number().int().nonnegative(),
-  semantic_unknown_count: z.number().int().nonnegative(),
+  application_unknown_count: z.int().nonnegative(),
+  semantic_unknown_count: z.int().nonnegative(),
 });
 
 export type JavaScriptApplicationSourceCoverage = z.infer<

src/domain/analysisView/javascriptModuleReferences.ts

@@ -22,8 +22,8 @@ export const javascriptModuleReferencesRequestSchema = z.strictObject({
       kind: moduleKindSchema.optional(),
     })
     .default({}),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 /** Unique support states, without promoting mixed observations to one fact. */
@@ -39,7 +39,7 @@ export const javascriptModuleReferenceSchema = z.strictObject({
   kind: moduleKindSchema,
   path: z.string().nullable(),
   identity: applicationNodeIdentitySchema,
-  retained_source_range_count: z.number().int().nonnegative(),
+  retained_source_range_count: z.int().nonnegative(),
   basis: z.array(basisSchema).min(1),
 });
 

src/domain/analysisView/machoView.ts

@@ -32,8 +32,8 @@ type MachoCollection = (typeof MACHO_COLLECTIONS)[number];
 export const machoViewRequestSchema = z.strictObject({
   kind: z.literal("macho"),
   facet: z.enum([...MACHO_COLLECTIONS, "provenance"]),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 const { shape } = inspectMachoSchema;
@@ -59,13 +59,13 @@ export const machoViewItemSchema = z.union([
 
 /** The producer's own coverage of the paged collection, not of this page. */
 export const machoViewContextSchema = z.strictObject({
-  source_total: z.number().int().nonnegative().nullable(),
+  source_total: z.int().nonnegative().nullable(),
   source_exhaustive: z.boolean(),
 });
 
 const collectionCountSchema = z.strictObject({
-  returned: z.number().int().nonnegative(),
-  total: z.number().int().nonnegative().nullable(),
+  returned: z.int().nonnegative(),
+  total: z.int().nonnegative().nullable(),
   exhaustive: z.boolean(),
 });
 
@@ -83,8 +83,8 @@ export const machoSummarySchema = z.strictObject({
       MACHO_COLLECTIONS.map((name) => [name, collectionCountSchema]),
     ) as Record<MachoCollection, typeof collectionCountSchema>,
   ),
-  provenance_count: z.number().int().nonnegative(),
-  limitation_count: z.number().int().nonnegative(),
+  provenance_count: z.int().nonnegative(),
+  limitation_count: z.int().nonnegative(),
 });
 
 type MachoReport = z.output<typeof inspectMachoSchema>;

src/domain/analysisView/managedArtifactView.ts

@@ -22,8 +22,8 @@ import {
 export const managedViewRequestSchema = z.strictObject({
   kind: z.literal("managed"),
   collection: z.enum(["references", "resources", "attributes"]),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 export const managedViewItemSchema = z.union([
@@ -37,9 +37,9 @@ export const managedSummarySchema = managedArtifactInspectionSchema
   .omit({ references: true, resources: true, attributes: true })
   .extend({
     reported_counts: z.strictObject({
-      references: z.number().int().nonnegative(),
-      resources: z.number().int().nonnegative(),
-      attributes: z.number().int().nonnegative(),
+      references: z.int().nonnegative(),
+      resources: z.int().nonnegative(),
+      attributes: z.int().nonnegative(),
     }),
     identity_scope: managedMemberInspectionSchema.shape.identity_scope,
   });

src/domain/analysisView/managedMemberView.ts

@@ -34,8 +34,8 @@ export const managedMembersViewRequestSchema = z.strictObject({
     "field_accesses",
     "user_strings",
   ]),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 const rowsOf = <C extends string, S extends z.ZodArray>(
@@ -60,7 +60,7 @@ export const managedMembersViewPageSchema = z.discriminatedUnion("collection", [
 
 type ManagedMembersViewPage = z.infer<typeof managedMembersViewPageSchema>;
 
-const nullableCount = z.number().int().nonnegative().nullable();
+const nullableCount = z.int().nonnegative().nullable();
 
 /** Keep identity, selection and coverage; member collections remain retained. */
 export const managedMemberSummarySchema = z.strictObject({
@@ -80,13 +80,13 @@ export const managedMemberSummarySchema = z.strictObject({
     .nullable(),
   limitations: member.limitations,
   reported_counts: z.strictObject({
-    types: z.number().int().nonnegative(),
+    types: z.int().nonnegative(),
     exported_types: nullableCount,
-    fields: z.number().int().nonnegative(),
-    methods: z.number().int().nonnegative(),
-    member_refs: z.number().int().nonnegative(),
-    call_edges: z.number().int().nonnegative(),
-    field_accesses: z.number().int().nonnegative(),
+    fields: z.int().nonnegative(),
+    methods: z.int().nonnegative(),
+    member_refs: z.int().nonnegative(),
+    call_edges: z.int().nonnegative(),
+    field_accesses: z.int().nonnegative(),
     user_strings: nullableCount,
   }),
 });

src/domain/analysisView/pcapCaptureView.ts

@@ -19,8 +19,8 @@ const captureSchema = pcapResultSchemas.inspect_pcap_capture;
 const fields = captureSchema.shape;
 const pageShape = {
   kind: z.literal("pcap"),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 };
 export const pcapViewRequestSchema = z.discriminatedUnion("facet", [
   z.strictObject({
@@ -51,7 +51,7 @@ export const pcapViewPageSchema = z.discriminatedUnion("facet", [
     facet: z.literal("dns-queries"),
     items: z.array(
       fields.dns_queries.element.omit({ response_addresses: true }).extend({
-        retained_response_address_count: z.number().int().nonnegative(),
+        retained_response_address_count: z.int().nonnegative(),
       }),
     ),
   }),
@@ -90,17 +90,17 @@ export const pcapSummarySchema = captureSchema
   })
   .extend({
     retained_counts: z.strictObject({
-      endpoints: z.number().int().nonnegative(),
-      dns_queries: z.number().int().nonnegative(),
-      tls_sni_values: z.number().int().nonnegative(),
-      protocol_distribution: z.number().int().nonnegative(),
-      http_request_uris: z.number().int().nonnegative(),
-      unattributed_dns_addresses: z.number().int().nonnegative(),
+      endpoints: z.int().nonnegative(),
+      dns_queries: z.int().nonnegative(),
+      tls_sni_values: z.int().nonnegative(),
+      protocol_distribution: z.int().nonnegative(),
+      http_request_uris: z.int().nonnegative(),
+      unattributed_dns_addresses: z.int().nonnegative(),
     }),
     diagnostics_code_units: z
       .strictObject({
-        tshark: z.number().int().nonnegative(),
-        capinfos: z.number().int().nonnegative(),
+        tshark: z.int().nonnegative(),
+        capinfos: z.int().nonnegative(),
       })
       .nullable(),
   });

src/domain/analysisView/qlogCaptureView.ts

@@ -14,19 +14,19 @@ export const qlogViewContextSchema = qlogCaptureFactsSchema.omit({
   traces: true,
 });
 export const qlogSummarySchema = qlogViewContextSchema.extend({
-  trace_count: z.number().int().nonnegative(),
-  retained_stream_count: z.number().int().nonnegative(),
-  loss_declaration_count: z.number().int().nonnegative(),
-  incomplete_fact_record_count: z.number().int().nonnegative(),
+  trace_count: z.int().nonnegative(),
+  retained_stream_count: z.int().nonnegative(),
+  loss_declaration_count: z.int().nonnegative(),
+  incomplete_fact_record_count: z.int().nonnegative(),
 });
 
 /** Select retained trace facts without copying event inventories or every contribution. */
 const pageRequestShape = {
   kind: z.literal("qlog"),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 };
-const traceSelectorShape = { trace_index: z.number().int().nonnegative() };
+const traceSelectorShape = { trace_index: z.int().nonnegative() };
 const streamSelectorShape = {
   ...traceSelectorShape,
   stream_id: streamSchema.shape.stream_id,
@@ -74,9 +74,9 @@ const traceSummarySchema = traceSchema
     incomplete_fact_records: true,
   })
   .extend({
-    stream_count: z.number().int().nonnegative(),
-    loss_declaration_count: z.number().int().nonnegative(),
-    incomplete_fact_record_count: z.number().int().nonnegative(),
+    stream_count: z.int().nonnegative(),
+    loss_declaration_count: z.int().nonnegative(),
+    incomplete_fact_record_count: z.int().nonnegative(),
   });
 const streamSummarySchema = streamSchema
   .omit({
@@ -85,9 +85,9 @@ const streamSummarySchema = streamSchema
     reported_final_sizes: true,
   })
   .extend({
-    contribution_count: z.number().int().nonnegative(),
-    covered_range_count: z.number().int().nonnegative(),
-    reported_final_size_count: z.number().int().nonnegative(),
+    contribution_count: z.int().nonnegative(),
+    covered_range_count: z.int().nonnegative(),
+    reported_final_size_count: z.int().nonnegative(),
   });
 /** Each page advertises exactly the retained item contract for its facet. */
 export const qlogViewPageSchema = z.discriminatedUnion("facet", [

src/domain/analysisView/wasmArtifactView.ts

@@ -33,8 +33,8 @@ export const wasmViewRequestSchema = z.strictObject({
     "details",
     "tool_profile",
   ]),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 export const wasmViewItemSchema = z.union([
@@ -51,19 +51,19 @@ export const wasmSummarySchema = z.strictObject({
   bytes: wasmArtifactSchema.shape.artifact.shape.bytes,
   validation: wasmArtifactSchema.shape.validation,
   available_counts: z.strictObject({
-    sections: z.number().int().nonnegative(),
-    imports: z.number().int().nonnegative(),
-    exports: z.number().int().nonnegative(),
-    candidates: z.number().int().nonnegative(),
-    glue: z.number().int().nonnegative(),
+    sections: z.int().nonnegative(),
+    imports: z.int().nonnegative(),
+    exports: z.int().nonnegative(),
+    candidates: z.int().nonnegative(),
+    glue: z.int().nonnegative(),
   }),
   wat: wasmArtifactSchema.shape.wat
     .omit({ text: true })
-    .extend({ code_units: z.number().int().nonnegative() }),
+    .extend({ code_units: z.int().nonnegative() }),
   tool_profile: wasmArtifactSchema.shape.tool_profile,
   runtime_execution: wasmArtifactSchema.shape.runtime_execution,
   network_fetch: wasmArtifactSchema.shape.network_fetch,
-  limitation_count: z.number().int().nonnegative(),
+  limitation_count: z.int().nonnegative(),
 });
 
 /** Read the exact retained WABT forms with source identity and explicit uncertainty. */

src/domain/analysisView/webNetworkApiSurfaceView.ts

@@ -13,8 +13,8 @@ import { ROUTE_RULES } from "./webNetworkRouteTemplates.js";
 
 export const apiSurfaceViewSchema = z.strictObject({
   kind: z.literal("api-surface"),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(50),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(50),
   include_query_parameter_names: z
     .boolean()
     .optional()
@@ -29,20 +29,20 @@ const groupSchema = z.strictObject({
   path_template: z.string(),
   templated_segments: z.array(
     z.strictObject({
-      segment_index: z.number().int().nonnegative(),
+      segment_index: z.int().nonnegative(),
       rule: ruleSchema,
       basis: z.literal("inferred"),
       observed_values: z.array(z.string()),
     }),
   ),
-  record_ordinals: z.array(z.number().int().nonnegative()),
+  record_ordinals: z.array(z.int().nonnegative()),
   statuses: z.array(z.number()),
   content_types: z.array(z.string()),
   query_parameter_names: z
     .array(
       z.strictObject({
         name: z.string(),
-        record_ordinals: z.array(z.number().int().nonnegative()),
+        record_ordinals: z.array(z.int().nonnegative()),
       }),
     )
     .optional(),
@@ -52,12 +52,11 @@ const groupSchema = z.strictObject({
 });
 export const apiSurfaceFields = {
   records: z.strictObject({
-    examined: z.number().int().nonnegative(),
-    total: z.number().int().nonnegative(),
-    excluded: z.number().int().nonnegative(),
+    examined: z.int().nonnegative(),
+    total: z.int().nonnegative(),
+    excluded: z.int().nonnegative(),
   }),
   templated_groups: z
-    .number()
     .int()
     .nonnegative()
     .describe(
@@ -66,7 +65,7 @@ export const apiSurfaceFields = {
   groups: z.array(groupSchema),
   excluded_records: z.array(
     z.strictObject({
-      ordinal: z.number().int().nonnegative(),
+      ordinal: z.int().nonnegative(),
       reason: z.enum([
         "url-redacted",
         "url-unparseable",

src/domain/analysisView/webNetworkCaptureView.ts

@@ -36,8 +36,8 @@ import {
 export const captureViewRequestSchema = z.strictObject({
   kind: z.literal("capture"),
   detail: z.enum(["preview", "complete"]).default("preview"),
-  offset: z.number().int().nonnegative().default(0),
-  limit: z.number().int().positive().default(64),
+  offset: z.int().nonnegative().default(0),
+  limit: z.int().positive().default(64),
 });
 
 const protobufSummarySchema = z.strictObject({
@@ -73,8 +73,8 @@ export const captureSummarySchema = z.strictObject({
   artifact: webNetworkCaptureArtifactSchema,
   decoder: webNetworkCaptureDecoderSchema,
   format: z.enum(WEB_NETWORK_CAPTURE_FORMATS),
-  total_records: z.number().int().nonnegative(),
-  retained_records: z.number().int().nonnegative(),
+  total_records: z.int().nonnegative(),
+  retained_records: z.int().nonnegative(),
   runtime_attribution: z.literal("unknown"),
   protobuf: protobufSummarySchema.exactOptional(),
   qlog: qlogSummarySchema.optional(),

src/domain/android/androidAnalysis.ts

@@ -25,7 +25,6 @@ export const androidInputSchemas = {
     ...classTarget,
     method_name: z.string().min(1),
     overload_index: z
-      .number()
       .int()
       .nonnegative()
       .optional()
@@ -43,7 +42,6 @@ export const androidInputSchemas = {
         "Omit for class references; select ambiguous methods with overload_index",
       ),
     overload_index: z
-      .number()
       .int()
       .nonnegative()
       .optional()
@@ -96,7 +94,7 @@ export const androidRequestSchema = z.discriminatedUnion("operation", [
 const textCoverage = z.strictObject({
   status: z.enum(["complete", "partial"]),
   text: z.string(),
-  reported_total_bytes: z.number().int().nonnegative().nullable(),
+  reported_total_bytes: z.int().nonnegative().nullable(),
 });
 /** A DEX prototype; hex parentheses also keep the advertised class valid in v mode. */
 export const dexDescriptorSchema = z
@@ -108,7 +106,7 @@ export const dexDescriptorSchema = z
 const method = z.strictObject({
   name: z.string(),
   reported_signature: z.string(),
-  overload_index: z.number().int().nonnegative(),
+  overload_index: z.int().nonnegative(),
   is_constructor: z.boolean(),
   dex_descriptor: dexDescriptorSchema,
 });
@@ -117,8 +115,8 @@ const engine = z.strictObject({
   version: z.string().nullable(),
   artifact_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
   source_revision: z.string().nullable(),
-  worker_count: z.number().int().positive(),
-  heap_limit_mib: z.number().int().positive().nullable(),
+  worker_count: z.int().positive(),
+  heap_limit_mib: z.int().positive().nullable(),
 });
 const common = { engine };
 
@@ -133,19 +131,19 @@ export const androidResultSchemas = {
     target_sdk: z.string().nullable(),
     permissions: z.array(z.string()),
     manifest: textCoverage,
-    class_count: z.number().int().nonnegative(),
-    resource_count: z.number().int().nonnegative(),
+    class_count: z.int().nonnegative(),
+    resource_count: z.int().nonnegative(),
     signature_verification: z.literal("not_performed"),
   }),
   search_android_classes: z.strictObject({
     ...common,
     query: z.string(),
-    total_classes: z.number().int().nonnegative(),
+    total_classes: z.int().nonnegative(),
     matches: z.array(z.string()),
     duplicate_names: z.array(
       z.strictObject({
         name: z.string(),
-        occurrences: z.number().int().min(2),
+        occurrences: z.int().min(2),
       }),
     ),
     coverage: z.literal("complete"),
@@ -163,7 +161,7 @@ export const androidResultSchemas = {
     ...common,
     class_name: z.string(),
     method: method,
-    overload_count: z.number().int().positive(),
+    overload_count: z.int().positive(),
     representation: z.enum(["java", "smali"]),
     body_status: z.enum(["available", "not_available"]),
     fell_back: z.boolean(),
@@ -174,10 +172,10 @@ export const androidResultSchemas = {
     ...common,
     class_name: z.string(),
     method_name: z.string().nullable(),
-    overload_index: z.number().int().nonnegative().nullable(),
+    overload_index: z.int().nonnegative().nullable(),
     reported_signature: z.string().nullable(),
     dex_descriptor: dexDescriptorSchema.nullable(),
-    total: z.number().int().nonnegative(),
+    total: z.int().nonnegative(),
     references: z.array(
       z.strictObject({
         kind: z.string(),
@@ -195,8 +193,8 @@ export const androidResultSchemas = {
             z.strictObject({
               dex_entry: z.string().min(1),
               source_raw_method_id: z.string().min(1),
-              dex_code_unit_offset: z.number().int().nonnegative(),
-              dex_method_index: z.number().int().nonnegative(),
+              dex_code_unit_offset: z.int().nonnegative(),
+              dex_method_index: z.int().nonnegative(),
               opcode: z.string().regex(/^INVOKE_/u),
             }),
           )

src/domain/apktool/apktoolResourceAnalysis.ts

@@ -155,7 +155,6 @@ export const stringTableSchema = z.strictObject({
     }),
   ),
   total_count: z
-    .number()
     .int()
     .nonnegative()
     .nullable()
@@ -163,7 +162,6 @@ export const stringTableSchema = z.strictObject({
       "Total valid string entries before output limits, or null if the table was not examined or was malformed",
     ),
   unparsed_count: z
-    .number()
     .int()
     .nonnegative()
     .nullable()
@@ -184,7 +182,7 @@ export const apktoolResultSchemas = {
     client,
     target: z.strictObject({
       path: localPathStringSchema,
-      bytes: z.number().int().nonnegative(),
+      bytes: z.int().nonnegative(),
       sha256: digestSchema,
     }),
     metadata: z.strictObject({
@@ -218,7 +216,7 @@ export const apktoolResultSchemas = {
       .describe(
         "Selected table facts, included when locales is supplied or string_tables_only is true",
       ),
-    decoded_file_count: z.number().int().nonnegative(),
+    decoded_file_count: z.int().nonnegative(),
     coverage: z.enum(["complete", "partial"]),
   }),
 } as const;

src/domain/apple/appleAssetCatalog.ts

@@ -29,20 +29,20 @@ export const appleResourceKeyFields = (
 
 /** Caller-controlled page bounds for compiled Apple asset metadata. */
 export const appleAssetCatalogInputSchema = z.strictObject({
-  offset: z.number().int().min(0).default(0),
-  limit: z.number().int().min(1).max(10_000).default(1_000),
+  offset: z.int().min(0).default(0),
+  limit: z.int().min(1).max(10_000).default(1_000),
 });
 
 const catalogSchema = z.strictObject({
   path: z.string().min(1),
   sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  record_count: z.number().int().nonnegative(),
+  record_count: z.int().nonnegative(),
 });
 
 const recordSchema = z.strictObject({
   catalog_path: z.string().min(1),
   catalog_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  index: z.number().int().nonnegative(),
+  index: z.int().nonnegative(),
   kind: z.enum(["catalog", "rendition"]),
   asset_name: z.string().nullable(),
   rendition_name: z.string().nullable(),
@@ -60,7 +60,7 @@ const resourceKeyMatchSchema = z.strictObject({
     z.strictObject({
       catalog_path: z.string().min(1),
       catalog_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-      record_index: z.number().int().nonnegative(),
+      record_index: z.int().nonnegative(),
       rendition_name: z.string().nullable(),
     }),
   ),
@@ -71,12 +71,12 @@ export const appleAssetCatalogResultSchema = bundleResourceBoundResultSchema(
   z.string().regex(/^[a-f0-9]{64}$/u),
   {
     catalogs: z.array(catalogSchema),
-    total_records: z.number().int().nonnegative(),
-    offset: z.number().int().nonnegative(),
-    limit: z.number().int().positive(),
+    total_records: z.int().nonnegative(),
+    offset: z.int().nonnegative(),
+    limit: z.int().positive(),
     records: z.array(recordSchema),
     resource_key_matches: z.array(resourceKeyMatchSchema),
-    next_offset: z.number().int().nonnegative().nullable(),
+    next_offset: z.int().nonnegative().nullable(),
     truncated: z.boolean(),
     limitations: z.array(z.string()),
   },

src/domain/apple/dylibResolution.ts

@@ -82,19 +82,19 @@ const dependencySchema = z.strictObject({
 export const machoSliceSchema = z.strictObject({
   architecture: z.string().min(1),
   /** Physical identity observed in the thin header and, for FAT, its table. */
-  slice_offset: z.number().int().nonnegative(),
-  slice_size: z.number().int().positive(),
-  cpu_type: z.number().int().nonnegative(),
-  cpu_subtype: z.number().int().nonnegative(),
-  fat_cpu_type: z.number().int().nonnegative().nullable(),
-  fat_cpu_subtype: z.number().int().nonnegative().nullable(),
-  fat_alignment_exponent: z.number().int().nonnegative().nullable(),
+  slice_offset: z.int().nonnegative(),
+  slice_size: z.int().positive(),
+  cpu_type: z.int().nonnegative(),
+  cpu_subtype: z.int().nonnegative(),
+  fat_cpu_type: z.int().nonnegative().nullable(),
+  fat_cpu_subtype: z.int().nonnegative().nullable(),
+  fat_alignment_exponent: z.int().nonnegative().nullable(),
   file_type: z.enum(["execute", "dylib", "bundle", "other"]),
-  file_type_code: z.number().int().nonnegative(),
+  file_type_code: z.int().nonnegative(),
   /** Raw LC_BUILD_VERSION platform number; null means no such command was observed. */
-  platform: z.number().int().nonnegative().nullable(),
+  platform: z.int().nonnegative().nullable(),
   /** Every distinct build platform declared by LC_BUILD_VERSION/version-min commands. */
-  platforms: z.array(z.number().int().nonnegative()),
+  platforms: z.array(z.int().nonnegative()),
   install_name: z.string().nullable(),
   dependencies: z.array(dependencySchema),
   rpaths: z.array(z.string()),
@@ -182,7 +182,7 @@ const findingSchema = z.strictObject({
     "earlier-rpath-candidate-absent",
     "dyld-environment-present",
   ]),
-  edge_index: z.number().int().nonnegative().nullable(),
+  edge_index: z.int().nonnegative().nullable(),
   image: z.string().nullable(),
   basis: z.literal("derived"),
   explanation: z.string().min(1),

src/domain/apple/interfaceBuilderGraph.ts

@@ -26,8 +26,8 @@ export const interfaceBuilderDocumentSchema = z.strictObject({
   relative_path: z.string().min(1),
   archive_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
   document_kind: z.enum(["nib", "storyboard_scene"]),
-  object_count: z.number().int().nonnegative(),
-  connection_count: z.number().int().nonnegative(),
+  object_count: z.int().nonnegative(),
+  connection_count: z.int().nonnegative(),
   hierarchy_complete: z.boolean(),
 });
 
@@ -620,9 +620,9 @@ export const buildInterfaceBuilderAnalysis = (input: {
 
 /** Hard limits shared by Interface Builder archive aggregation and tracing. */
 export const interfaceBuilderLimitsSchema = z.strictObject({
-  max_documents: z.number().int().min(1).max(64).default(64),
-  max_objects: z.number().int().min(1).max(20_000).default(20_000),
-  max_connections: z.number().int().min(1).max(40_000).default(40_000),
+  max_documents: z.int().min(1).max(64).default(64),
+  max_objects: z.int().min(1).max(20_000).default(20_000),
+  max_connections: z.int().min(1).max(40_000).default(40_000),
   trace: nativeInvestigationTraceLimitsSchema.default({
     max_depth: 8,
     max_nodes: 250,

src/domain/apple/keyedArchive.ts

@@ -25,13 +25,13 @@ export class KeyedArchiveKindError extends TypeError {
 export const keyedArchiveInputSchema = z.strictObject({
   path: localPathStringSchema.default("."),
   root: z.string().optional(),
-  offset: z.number().int().min(0).default(0),
-  limit: z.number().int().min(1).max(20_000).default(20_000),
+  offset: z.int().min(0).default(0),
+  limit: z.int().min(1).max(20_000).default(20_000),
 });
 const linkSchema = z.strictObject({
-  source: z.number().int().nonnegative().nullable(),
-  path: z.array(z.union([z.string(), z.number().int().nonnegative()])),
-  target: z.number().int().nonnegative().nullable(),
+  source: z.int().nonnegative().nullable(),
+  path: z.array(z.union([z.string(), z.int().nonnegative()])),
+  target: z.int().nonnegative().nullable(),
   status: z.enum(["resolved", "nil", "unresolved", "malformed"]),
   raw: jsonValueSchema,
 });
@@ -45,7 +45,7 @@ export const keyedArchiveResultSchema = bundleResourceBoundResultSchema(
     roots: z.record(z.string(), jsonValueSchema),
     objects: z.array(
       z.strictObject({
-        id: z.number().int().nonnegative(),
+        id: z.int().nonnegative(),
         kind: z.enum([
           "nil",
           "scalar",
@@ -54,7 +54,7 @@ export const keyedArchiveResultSchema = bundleResourceBoundResultSchema(
           "class-descriptor",
           "archived-object",
         ]),
-        class_id: z.number().int().nonnegative().nullable(),
+        class_id: z.int().nonnegative().nullable(),
         class_name: z.string().nullable(),
         status: z.enum([
           "observed",
@@ -66,10 +66,10 @@ export const keyedArchiveResultSchema = bundleResourceBoundResultSchema(
       }),
     ),
     references: z.array(linkSchema),
-    total_objects: z.number().int().nonnegative(),
-    total_references: z.number().int().nonnegative(),
-    offset: z.number().int().nonnegative(),
-    next_offset: z.number().int().nonnegative().nullable(),
+    total_objects: z.int().nonnegative(),
+    total_references: z.int().nonnegative(),
+    offset: z.int().nonnegative(),
+    next_offset: z.int().nonnegative().nullable(),
     truncated: z.boolean(),
     limitations: z.array(z.string()),
   },

src/domain/artifactComparison.ts

@@ -79,12 +79,12 @@ export const artifactComparisonResultSchema = z.object({
   left_manifest_id: prefixedDigestSchema("agm"),
   right_manifest_id: prefixedDigestSchema("agm"),
   summary: z.object({
-    unchanged: z.number().int().min(0),
-    added: z.number().int().min(0),
-    removed: z.number().int().min(0),
-    changed: z.number().int().min(0),
-    unknown: z.number().int().min(0),
-    contradiction: z.number().int().min(0).default(0),
+    unchanged: z.int().min(0),
+    added: z.int().min(0),
+    removed: z.int().min(0),
+    changed: z.int().min(0),
+    unknown: z.int().min(0),
+    contradiction: z.int().min(0).default(0),
   }),
   changes: z.array(artifactChangeSchema),
   limitations: z.array(z.string()),

src/domain/artifactGraph.ts

@@ -104,8 +104,8 @@ const artifactContentFormatSchema = artifactFormatSchema.extract([
 
 /** File byte interval for an artifact derived without writing it to disk. */
 const artifactByteRangeSchema = z.object({
-  offset: z.number().int().min(0),
-  length: z.number().int().min(0),
+  offset: z.int().min(0),
+  length: z.int().min(0),
 });
 
 /** External command provenance, including observable side effects. */
@@ -114,7 +114,7 @@ const artifactCommandSchema = z.object({
   arguments: z.array(z.string()),
   tool_version: z.string().nullable(),
   executable_sha256: sha256Schema.nullable(),
-  exit_code: z.number().int().nullable(),
+  exit_code: z.int().nullable(),
   effects: z.array(z.enum(["read", "write", "mount"])),
 });
 
@@ -126,7 +126,7 @@ export const artifactNodeSchema = z.object({
   artifact_id: artifactIdSchema,
   format: artifactContentFormatSchema,
   sha256: sha256Schema,
-  size: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  size: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
   media_type: z.string().min(1).nullable(),
   architecture: z.string().min(1).nullable(),
   content_state: z.enum(["materialized", "embedded", "virtual"]),
@@ -142,18 +142,8 @@ export const artifactOccurrenceSchema = z.object({
   entry_kind: z.enum(["file", "directory", "symlink", "slice", "metadata"]),
   artifact_kind: artifactKindSchema,
   artifact_format: artifactFormatSchema,
-  declared_size: z
-    .number()
-    .int()
-    .min(0)
-    .max(Number.MAX_SAFE_INTEGER)
-    .nullable(),
-  compressed_size: z
-    .number()
-    .int()
-    .min(0)
-    .max(Number.MAX_SAFE_INTEGER)
-    .nullable(),
+  declared_size: z.int().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
+  compressed_size: z.int().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
   executable: z.boolean(),
   encrypted: z.boolean(),
   hash_status: z.enum(["verified", "mismatched", "not-hashed", "unavailable"]),
@@ -188,7 +178,7 @@ export const integrityContradictionSchema = z.union([
  */
 export const artifactEdgeSchema = z.object({
   edge_id: edgeIdSchema,
-  ordinal: z.number().int().min(0),
+  ordinal: z.int().min(0),
   parent_artifact_id: artifactIdSchema,
   relation: z.enum([
     "contains",
@@ -210,9 +200,9 @@ export const artifactGraphManifestSchema = z.object({
   root_sha256: sha256Schema,
   root_format: artifactFormatSchema,
   graph_sha256: sha256Schema,
-  node_count: z.number().int().min(1),
-  occurrence_count: z.number().int().min(1),
-  edge_count: z.number().int().min(0),
+  node_count: z.int().min(1),
+  occurrence_count: z.int().min(1),
+  edge_count: z.int().min(0),
 });
 
 /** Producer-owned traversal coverage; content certainty remains on each occurrence. */
@@ -241,7 +231,7 @@ const extractedArtifactSchema = z.object({
   artifact_id: artifactIdSchema,
   relative_path: boundedRelativePathSchema,
   sha256: sha256Schema,
-  bytes_written: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  bytes_written: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
   created: z.boolean(),
 });
 

src/domain/artifactInspection.ts

@@ -97,15 +97,15 @@ export const artifactInspectionResultSchema = z.strictObject({
   next_probes: z.array(nextProbeSchema),
   coverage: z.strictObject({
     status: z.enum(["complete-within-substeps", "partial", "truncated"]),
-    substeps_completed: z.number().int().min(1),
-    observations_retained: z.number().int().min(0),
-    observations_omitted: z.number().int().min(0),
-    hypotheses_retained: z.number().int().min(0),
-    hypotheses_omitted: z.number().int().min(0),
-    unexplored_branches_retained: z.number().int().min(0),
-    unexplored_branches_omitted: z.number().int().min(0),
-    next_probes_retained: z.number().int().min(0),
-    next_probes_omitted: z.number().int().min(0),
+    substeps_completed: z.int().min(1),
+    observations_retained: z.int().min(0),
+    observations_omitted: z.int().min(0),
+    hypotheses_retained: z.int().min(0),
+    hypotheses_omitted: z.int().min(0),
+    unexplored_branches_retained: z.int().min(0),
+    unexplored_branches_omitted: z.int().min(0),
+    next_probes_retained: z.int().min(0),
+    next_probes_omitted: z.int().min(0),
   }),
   evidence_links: z.array(evidenceIdSchema).min(1),
   limitations: z.array(textSchema),

src/domain/bridgeCandidateProjection.ts

@@ -3,9 +3,9 @@ import { z } from "zod";
 /** Coverage metadata for the bounded projection of candidate relationships. */
 export const bridgeCandidateCoverageSchema = z.strictObject({
   status: z.enum(["complete", "partial"]),
-  total_candidates: z.number().int().nonnegative(),
-  emitted_candidates: z.number().int().nonnegative(),
-  omitted_candidates: z.number().int().nonnegative(),
+  total_candidates: z.int().nonnegative(),
+  emitted_candidates: z.int().nonnegative(),
+  omitted_candidates: z.int().nonnegative(),
 });
 
 // The serialized candidate array is the retained representation; accounting

src/domain/browserCompleteness.ts

@@ -47,19 +47,19 @@ export type BrowserExclusionReason = z.infer<
 const browserExclusionSchema = z.object({
   section: browserSectionSchema,
   reason: browserExclusionReasonSchema,
-  count: z.number().int().min(0).nullable(),
+  count: z.int().min(0).nullable(),
 });
 export type BrowserExclusion = z.infer<typeof browserExclusionSchema>;
 
 const browserDroppedEventsSchema = z.object({
-  scripts: z.number().int().min(0),
-  network_requests: z.number().int().min(0),
-  console_events: z.number().int().min(0),
-  websocket_connections: z.number().int().min(0),
-  websocket_frames: z.number().int().min(0),
-  webmcp_tools: z.number().int().min(0),
-  timeline_events: z.number().int().min(0),
-  total: z.number().int().min(0),
+  scripts: z.int().min(0),
+  network_requests: z.int().min(0),
+  console_events: z.int().min(0),
+  websocket_connections: z.int().min(0),
+  websocket_frames: z.int().min(0),
+  webmcp_tools: z.int().min(0),
+  timeline_events: z.int().min(0),
+  total: z.int().min(0),
 });
 export type BrowserDroppedEvents = z.infer<typeof browserDroppedEventsSchema>;
 export type BrowserDroppedEventKind = Exclude<

src/domain/browserNetworkEvidence.ts

@@ -43,15 +43,15 @@ const unavailableBrowserNetworkBodySchema = z.discriminatedUnion("reason", [
     state: z.literal("unavailable"),
     reason: z.literal("body-size-limit"),
     message: z.string().min(1),
-    limit_bytes: z.number().int().positive().safe(),
-    observed_bytes: z.number().int().positive().safe(),
+    limit_bytes: z.int().positive().safe(),
+    observed_bytes: z.int().positive().safe(),
   }),
   z.strictObject({
     state: z.literal("unavailable"),
     reason: z.literal("body-allocation-limit"),
     message: z.string().min(1),
-    limit_allocation_bytes: z.number().int().positive().safe(),
-    observed_allocation_bytes: z.number().int().positive().safe(),
+    limit_allocation_bytes: z.int().positive().safe(),
+    observed_allocation_bytes: z.int().positive().safe(),
   }),
 ]);
 
@@ -71,7 +71,7 @@ export const browserNetworkBodySchema = z.union([
       ]),
       encoding: z.literal("base64"),
       content: z.string(),
-      bytes: z.number().int().min(0),
+      bytes: z.int().min(0),
       sha256: z.string().regex(/^[a-f0-9]{64}$/u),
       media_type: z.string().nullable(),
       redacted: z.boolean(),

src/domain/browserObservation.ts

@@ -183,7 +183,7 @@ const inspectWebPageInputFacts = {
   ...browserInput,
   target_id: z.string().trim().min(1),
   command_timeout_ms: webRuntimeCommandTimeoutSchema,
-  observation_ms: z.number().int().min(0).default(500),
+  observation_ms: z.int().min(0).default(500),
   include_accessibility_text: z.boolean().default(false),
   include_console_text: z.boolean().default(false),
   include_json_body_shapes: z.boolean().default(false),

src/domain/browserObservationSchemas.ts

@@ -37,9 +37,9 @@ export const browserTargetListSchema = z.object({
   browser: browserVersionSchema,
   targets: z.array(browserTargetSchema),
   excluded: z.object({
-    disallowed_origin: z.number().int().min(0),
-    unsupported_url: z.number().int().min(0),
-    non_page: z.number().int().min(0),
+    disallowed_origin: z.int().min(0),
+    unsupported_url: z.int().min(0),
+    non_page: z.int().min(0),
   }),
   limitations: z.array(z.string()),
 });
@@ -123,8 +123,8 @@ const browserNetworkRequestSchema = z.object({
   initiator: z.object({
     type: z.string(),
     url: z.string().nullable(),
-    line: z.number().int().min(0).nullable(),
-    column: z.number().int().min(0).nullable(),
+    line: z.int().min(0).nullable(),
+    column: z.int().min(0).nullable(),
   }),
   body_shapes: z.object({
     status: z.enum(["not_approved", "included", "partial", "unavailable"]),
@@ -147,24 +147,24 @@ const browserConsoleEventSchema = z.object({
       "CDP argument types by argument position; null when the producer argument inventory is absent or not an array.",
     ),
   url: z.string().nullable(),
-  line: z.number().int().min(0).nullable(),
-  column: z.number().int().min(0).nullable(),
+  line: z.int().min(0).nullable(),
+  column: z.int().min(0).nullable(),
   text_capture: z.object({
     status: z.enum(["not_approved", "included", "unavailable"]),
     values: z.array(
       z.object({
-        argument_index: z.number().int().min(0),
+        argument_index: z.int().min(0),
         type: z.string(),
         text: z.string(),
       }),
     ),
-    retained_bytes: z.number().int().min(0),
+    retained_bytes: z.int().min(0),
   }),
 });
 const browserWebSocketFrameSchema = z.object({
   direction: z.enum(["sent", "received"]),
-  opcode: z.number().int().min(0).max(15).nullable(),
-  payload_bytes: z.number().int().min(0).nullable(),
+  opcode: z.int().min(0).max(15).nullable(),
+  payload_bytes: z.int().min(0).nullable(),
   payload_shape: z
     .object({
       format: z.enum(["json", "text", "binary"]),
@@ -221,7 +221,7 @@ const browserSafeMetadataSchema = z.object({
       request_id: z.string(),
       url: z.string(),
       mime_type: z.string().nullable(),
-      content_length: z.number().int().min(0).nullable(),
+      content_length: z.int().min(0).nullable(),
       content_encoding: z.string().nullable(),
       csp: z.object({
         directives: z.array(
@@ -230,8 +230,8 @@ const browserSafeMetadataSchema = z.object({
             sources: z.array(browserCspSourceSchema),
           }),
         ),
-        nonce_count: z.number().int().min(0),
-        hash_count: z.number().int().min(0),
+        nonce_count: z.int().min(0),
+        hash_count: z.int().min(0),
       }),
       links: z.array(browserLinkMetadataSchema),
       policies: z.object({
@@ -246,14 +246,14 @@ const browserSafeMetadataSchema = z.object({
   ),
   dom_urls: z.array(
     z.object({
-      node_index: z.number().int().min(0),
+      node_index: z.int().min(0),
       attribute: z.enum(["href", "src", "action", "formaction", "poster"]),
       url: z.string().nullable(),
       destination_scope: z.enum(["approved", "outside_policy", "unsupported"]),
     }),
   ),
   agent_hints: z.array(browserAgentHintSchema),
-  excluded_dom_urls: z.number().int().min(0),
+  excluded_dom_urls: z.int().min(0),
   headers_allowlisted: z.literal(true),
 });
 
@@ -264,25 +264,25 @@ export const webPageInspectionSchema = z.object({
   capture_window: z.object({
     started_at: z.iso.datetime(),
     ended_at: z.iso.datetime(),
-    observation_ms: z.number().int().min(0),
+    observation_ms: z.int().min(0),
   }),
   completeness: browserCompletenessSchema,
   frames: z.array(browserFrameSchema),
   dom: z.object({
-    total_nodes: z.number().int().min(0),
+    total_nodes: z.int().min(0),
     nodes: z.array(cdpDomNodeSchema),
   }),
   accessibility: z.object({
-    total_nodes: z.number().int().min(0),
+    total_nodes: z.int().min(0),
     text_capture: z.object({
       status: z.enum(["not_approved", "included", "unavailable"]),
-      retained_bytes: z.number().int().min(0),
-      excluded_fields: z.number().int().min(0),
+      retained_bytes: z.int().min(0),
+      excluded_fields: z.int().min(0),
     }),
     nodes: z.array(browserAxNodeSchema),
   }),
   scripts: z.object({
-    total: z.number().int().min(0),
+    total: z.int().min(0),
     items: z.array(browserScriptSchema),
   }),
   resources: z.array(browserResourceSchema),

src/domain/browserScenarioCapture.ts

@@ -22,17 +22,17 @@ export const browserScenarioCaptureSchema = z
     }),
     scenario: z.strictObject({
       start_origin: z.string().min(1),
-      action_count: z.number().int().min(1),
+      action_count: z.int().min(1),
       secret_references: z.array(z.string().min(1)),
       network_content: browserNetworkContentSelectionValuesSchema,
       event_families: z.array(browserScenarioEventFamilySchema),
       limits: browserScenarioCaptureLimitsValuesSchema,
     }),
-    duration_ms: z.number().int().min(0),
+    duration_ms: z.int().min(0),
     steps: z.array(browserScenarioStepSchema).min(1),
     events: z.strictObject({
-      retained: z.number().int().min(0),
-      dropped: z.number().int().min(0),
+      retained: z.int().min(0),
+      dropped: z.int().min(0),
       items: z.array(browserScenarioEventSchema),
       omissions: browserScenarioEventOmissionsSchema,
     }),

src/domain/browserScenarioCaptureLimits.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-const positiveSafeInteger = z.number().int().safe().positive();
+const positiveSafeInteger = z.int().safe().positive();
 
 export const DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS = {
   max_events: 10_000,

src/domain/browserScenarioCaptureValues.ts

@@ -14,7 +14,7 @@ import { digestSchema } from "./../domain/digests.js";
 const textArtifactSchema = z
   .strictObject({
     sha256: digestSchema,
-    bytes: z.number().int().min(0),
+    bytes: z.int().min(0),
     text: z.string(),
   })
   .superRefine((artifact, context) => {
@@ -39,14 +39,14 @@ export const captureStateSchema = <Schema extends z.ZodType>(value: Schema) =>
     }),
     z.strictObject({
       state: z.literal("truncated"),
-      observed: z.number().int().min(0),
-      retained: z.number().int().min(0),
+      observed: z.int().min(0),
+      retained: z.int().min(0),
       reason: z.string().min(1),
     }),
   ]);
 
 const historySchema = z.strictObject({
-  length: z.number().int().min(0),
+  length: z.int().min(0),
   current_url: sanitizedBrowserUrlSchema,
   navigation_entries: z.array(
     z.strictObject({
@@ -135,8 +135,8 @@ export type BrowserScenarioEventFamily = z.infer<
 >;
 
 const eventBase = {
-  sequence: z.number().int().min(1),
-  step_index: z.number().int().min(0),
+  sequence: z.int().min(1),
+  step_index: z.int().min(0),
 };
 
 const eventUrl = sanitizedBrowserUrlSchema.nullable();
@@ -155,7 +155,7 @@ const webSocketFrameShape = {
   ...eventBase,
   kind: z.enum(["websocket-frame-sent", "websocket-frame-received"]),
   url: sanitizedBrowserUrlSchema,
-  payload_bytes: z.number().int().min(0),
+  payload_bytes: z.int().min(0),
   truncated: z.boolean(),
 };
 
@@ -183,7 +183,7 @@ export const browserScenarioEventSchema = z
     z.strictObject({
       ...networkEventShape,
       kind: z.literal("response"),
-      status: z.number().int().min(100).max(599),
+      status: z.int().min(100).max(599),
       failure: z.null(),
     }),
     z.strictObject({
@@ -209,7 +209,7 @@ export const browserScenarioEventSchema = z
       ...eventBase,
       kind: z.literal("network-content"),
       transaction_id: z.string().min(1),
-      source_event_sequence: z.number().int().min(1),
+      source_event_sequence: z.int().min(1),
       phase: z.enum(["request", "response"]),
       headers: browserNetworkHeadersSchema,
       body: browserNetworkBodySchema,
@@ -314,7 +314,7 @@ export const browserScenarioEventOmissionsSchema = z.strictObject({
   by_kind: z.array(
     z.strictObject({
       kind: browserScenarioEventKindSchema,
-      count: z.number().int().positive(),
+      count: z.int().positive(),
       reasons: z.array(browserScenarioEventBudgetReasonSchema).min(1),
     }),
   ),
@@ -329,7 +329,7 @@ export const browserScenarioEventOmissionsSchema = z.strictObject({
     .strictObject({
       first_transaction_id: z.string().min(1),
       last_transaction_id: z.string().min(1),
-      count: z.number().int().positive(),
+      count: z.int().positive(),
       reason: z.literal("max-network-transactions"),
     })
     .nullable(),
@@ -408,14 +408,14 @@ export const classifyBrowserScenarioCompleteness = (
 };
 
 const browserScenarioStepShape = {
-  step_index: z.number().int().min(0),
+  step_index: z.int().min(0),
   step_id: z.string().min(1),
   action: z.string().min(1),
-  elapsed_ms: z.number().int().min(0),
+  elapsed_ms: z.int().min(0),
   before_url: sanitizedBrowserUrlSchema,
   after_url: sanitizedBrowserUrlSchema,
-  event_sequence_start: z.number().int().min(1),
-  event_sequence_end: z.number().int().min(0),
+  event_sequence_start: z.int().min(1),
+  event_sequence_end: z.int().min(0),
   artifacts: browserStepArtifactsSchema,
   completeness: browserScenarioCompletenessSchema,
 };

src/domain/browserScenarioDiffValues.ts

@@ -151,7 +151,7 @@ export const browserScenarioDiffSchema = z.strictObject({
   }),
   alignment: z.strictObject({
     status: z.enum(["aligned", "partial", "failed"]),
-    aligned_steps: z.number().int().min(0),
+    aligned_steps: z.int().min(0),
     before_only: z.array(z.string().min(1)),
     after_only: z.array(z.string().min(1)),
     failures: z.array(alignmentFailureSchema),
@@ -159,8 +159,8 @@ export const browserScenarioDiffSchema = z.strictObject({
   steps: z.array(
     z.strictObject({
       step_id: z.string().min(1),
-      before_step_index: z.number().int().min(0),
-      after_step_index: z.number().int().min(0),
+      before_step_index: z.int().min(0),
+      after_step_index: z.int().min(0),
       before_action: z.string().min(1),
       after_action: z.string().min(1),
       status: z.enum(["changed", "unchanged", "unknown"]),
@@ -168,7 +168,7 @@ export const browserScenarioDiffSchema = z.strictObject({
     }),
   ),
   artifact_diffs: z.strictObject({
-    total: z.number().int().min(0),
+    total: z.int().min(0),
   }),
   limitations: z.array(z.string().min(1)),
 });

src/domain/browserScenarioNetworkComparison.ts

@@ -7,8 +7,8 @@ import { normalizeScenarioValue } from "./browserScenarioNormalization.js";
 /** Numeric links are temporary local indices, never durable transaction identity. */
 export const scenarioNetworkTransactionSchema = z.strictObject({
   events: z.array(z.unknown()),
-  predecessor: z.number().int().min(-2),
-  step_index: z.number().int().min(0),
+  predecessor: z.int().min(-2),
+  step_index: z.int().min(0),
 });
 export type ScenarioNetworkTransaction = z.infer<
   typeof scenarioNetworkTransactionSchema

src/domain/browserScenarioValues.ts

@@ -98,8 +98,8 @@ export const browserScenarioEnvironmentSchema = z
   .strictObject({
     viewport: z
       .strictObject({
-        width: z.number().int().positive().default(1_280),
-        height: z.number().int().positive().default(720),
+        width: z.int().positive().default(1_280),
+        height: z.int().positive().default(720),
         device_scale_factor: z.number().positive().default(1),
       })
       .default({ width: 1_280, height: 720, device_scale_factor: 1 }),
@@ -169,7 +169,6 @@ const MAX_BROWSER_SCENARIO_TIMEOUT_MS = 2_147_483_647;
 const stepBase = {
   step_id: scenarioIdentifierSchema,
   timeout_ms: z
-    .number()
     .int()
     .min(1)
     .max(MAX_BROWSER_SCENARIO_TIMEOUT_MS)
@@ -191,7 +190,7 @@ export const browserScenarioActionSchema = z.discriminatedUnion("action", [
     action: z.literal("click"),
     locator: locatorSchema,
     button: z.enum(["left", "middle", "right"]).default("left"),
-    click_count: z.number().int().positive().default(1),
+    click_count: z.int().positive().default(1),
   }),
   z.strictObject({
     ...stepBase,
@@ -226,7 +225,6 @@ export const browserScenarioActionSchema = z.discriminatedUnion("action", [
     step_id: scenarioIdentifierSchema,
     action: z.literal("wait_for_timeout"),
     duration_ms: z
-      .number()
       .int()
       .min(1)
       .max(MAX_BROWSER_SCENARIO_TIMEOUT_MS)

src/domain/browserSession.ts

@@ -13,7 +13,7 @@ export const observeWebSessionInputSchema = z.strictObject({
   cdp_endpoint: browserObservationEndpointSchema,
   allowed_origins: browserAllowedOriginsSchema,
   target_id: z.string().trim().min(1),
-  observation_ms: z.number().int().min(1).default(10_000),
+  observation_ms: z.int().min(1).default(10_000),
   command_timeout_ms: webRuntimeCommandTimeoutSchema,
 });
 export type ObserveWebSessionInput = z.infer<
@@ -21,7 +21,7 @@ export type ObserveWebSessionInput = z.infer<
 >;
 
 const timelineEventSchema = z.object({
-  sequence: z.number().int().min(1),
+  sequence: z.int().min(1),
   type: z.enum([
     "navigation_requested",
     "navigation_committed",
@@ -62,7 +62,7 @@ export const webObservationSessionSchema = z.object({
   window: z.object({
     armed_at: z.iso.datetime(),
     ended_at: z.iso.datetime(),
-    requested_ms: z.number().int().min(1),
+    requested_ms: z.int().min(1),
     end_reason: z.enum([
       "window_elapsed",
       "target_left_scope",

src/domain/bundleComparison.ts

@@ -59,16 +59,16 @@ export const bundleComparisonResultSchema = z.object({
   left_bundle_sha256: digestSchema,
   right_bundle_sha256: digestSchema,
   summary: z.object({
-    records_unchanged: z.number().int().min(0),
-    records_added: z.number().int().min(0),
-    records_removed: z.number().int().min(0),
-    records_changed: z.number().int().min(0),
-    unknowns_unchanged: z.number().int().min(0),
-    unknowns_added: z.number().int().min(0),
-    unknowns_removed: z.number().int().min(0),
-    unknowns_advanced: z.number().int().min(0),
-    unknowns_diverged: z.number().int().min(0),
-    unresolved: z.number().int().min(0),
+    records_unchanged: z.int().min(0),
+    records_added: z.int().min(0),
+    records_removed: z.int().min(0),
+    records_changed: z.int().min(0),
+    unknowns_unchanged: z.int().min(0),
+    unknowns_added: z.int().min(0),
+    unknowns_removed: z.int().min(0),
+    unknowns_advanced: z.int().min(0),
+    unknowns_diverged: z.int().min(0),
+    unresolved: z.int().min(0),
   }),
   changes: z.array(bundleChangeSchema),
   limitations: z.array(z.string()),

src/domain/callPathSchemas.ts

@@ -28,7 +28,7 @@ const citedEdgeSchema = z.object({
 });
 const pathSchema = z
   .object({
-    hops: z.number().int().min(0),
+    hops: z.int().min(0),
     nodes: z.array(citedNodeSchema).min(1),
     edges: z.array(citedEdgeSchema),
     evidence_links: z.array(evidenceIdSchema).min(1),
@@ -53,9 +53,9 @@ const resultContextShape = {
   start: nativeAddressSchema,
   goal: nativeAddressSchema,
   explored: z.object({
-    nodes: z.number().int().min(0),
-    edges: z.number().int().min(0),
-    depth_reached: z.number().int().min(0),
+    nodes: z.int().min(0),
+    edges: z.int().min(0),
+    depth_reached: z.int().min(0),
   }),
   evidence_links: z.array(evidenceIdSchema).min(1),
   limitations: z.array(z.string()),
@@ -66,7 +66,7 @@ export const callPathResultSchema = z.union([
   z.object({
     ...resultContextShape,
     status: z.literal("found"),
-    shortest_hops: z.number().int().min(0),
+    shortest_hops: z.int().min(0),
     search_scope: z.object({ exhaustive: z.boolean() }),
     paths: z.array(pathSchema).min(1),
   }),

src/domain/changedBehavior.ts

@@ -56,10 +56,10 @@ export const changedBehaviorResultSchema = z
       "truncated",
     ]),
     summary: z.object({
-      observed_changes: z.number().int().min(0),
-      static_candidates: z.number().int().min(0),
-      contradictions: z.number().int().min(0),
-      unresolved: z.number().int().min(0),
+      observed_changes: z.int().min(0),
+      static_candidates: z.int().min(0),
+      contradictions: z.int().min(0),
+      unresolved: z.int().min(0),
     }),
     findings: z.object({
       items: z.array(findingSchema),

src/domain/completionLedgerGeneration.ts

@@ -28,7 +28,7 @@ const environmentSchema = z.strictObject({
 });
 const scenarioSchema = z.strictObject({
   id: identifierSchema,
-  version: z.number().int().positive(),
+  version: z.int().positive(),
 });
 const skillDigestSchema = z.strictObject({
   skill_id: identifierSchema,
@@ -37,29 +37,29 @@ const skillDigestSchema = z.strictObject({
 const verifierRunSchema = z
   .strictObject({
     run_id: z.string().uuid(),
-    verifier_pid: z.number().int().positive(),
-    parent_pid: z.number().int().nonnegative(),
+    verifier_pid: z.int().positive(),
+    parent_pid: z.int().nonnegative(),
     process_lineage: z.discriminatedUnion("status", [
       z.strictObject({
         status: z.literal("verified"),
         observed_at: z.iso.datetime(),
-        launcher_pid: z.number().int().positive(),
-        launcher_parent_pid: z.number().int().nonnegative(),
-        process_group_id: z.number().int().positive(),
+        launcher_pid: z.int().positive(),
+        launcher_parent_pid: z.int().nonnegative(),
+        process_group_id: z.int().positive(),
         descendants: z.array(
           z.strictObject({
-            pid: z.number().int().positive(),
-            parent_pid: z.number().int().nonnegative(),
-            process_group_id: z.number().int().positive(),
+            pid: z.int().positive(),
+            parent_pid: z.int().nonnegative(),
+            process_group_id: z.int().positive(),
           }),
         ),
       }),
       z.strictObject({
         status: z.literal("unavailable"),
         observed_at: z.iso.datetime(),
-        launcher_pid: z.number().int().positive(),
-        launcher_parent_pid: z.number().int().nonnegative(),
-        process_group_id: z.number().int().positive().nullable(),
+        launcher_pid: z.int().positive(),
+        launcher_parent_pid: z.int().nonnegative(),
+        process_group_id: z.int().positive().nullable(),
         reason: z.string().min(1),
       }),
     ]),

src/domain/conformancePackage.ts

@@ -19,7 +19,7 @@ const scenarioManifestSchema = z.strictObject({
   /** Source-owned fixture path relative to the repository root. */
   fixture_path: z.string().min(1),
   /** Expected exit code or null if unspecified. */
-  expected_exit_code: z.number().int().nullable(),
+  expected_exit_code: z.int().nullable(),
   /** Expected output patterns that must appear in the capture. */
   expected_patterns: z.array(z.string()).default([]),
 });
@@ -33,7 +33,7 @@ const replayPlanSchema = z.strictObject({
         step_id: z.string().min(1),
         action: z.string().min(1),
         arguments: z.array(z.string()).default([]),
-        timeout_ms: z.number().int().positive(),
+        timeout_ms: z.int().positive(),
       }),
     )
     .min(1),
@@ -77,7 +77,7 @@ const verifierContractSchema = z.strictObject({
     )
     .min(1),
   /** Tolerance for timing differences in milliseconds. */
-  timing_tolerance_ms: z.number().int().nonnegative().default(0),
+  timing_tolerance_ms: z.int().nonnegative().default(0),
 });
 
 const conformancePackageContentsSchema = z.strictObject({

src/domain/conformanceReplay.ts

@@ -10,8 +10,8 @@ import {
 export const scenarioReplayResultSchema = z.strictObject({
   scenario_id: z.string().min(1),
   status: z.enum(["pass", "fail", "error", "skipped"]),
-  exit_code: z.number().int().nullable(),
-  duration_ms: z.number().int().nonnegative(),
+  exit_code: z.int().nullable(),
+  duration_ms: z.int().nonnegative(),
   output: z.string().default(""),
   error: z.string().nullable(),
 });
@@ -20,11 +20,11 @@ export const scenarioReplayResultSchema = z.strictObject({
 export const packageReplayResultSchema = z
   .strictObject({
     package_id: z.string().min(1),
-    total_scenarios: z.number().int().positive(),
-    passed: z.number().int().nonnegative(),
-    failed: z.number().int().nonnegative(),
-    errored: z.number().int().nonnegative(),
-    skipped: z.number().int().nonnegative(),
+    total_scenarios: z.int().positive(),
+    passed: z.int().nonnegative(),
+    failed: z.int().nonnegative(),
+    errored: z.int().nonnegative(),
+    skipped: z.int().nonnegative(),
     scenario_results: z.array(scenarioReplayResultSchema),
     trust_gate_results: z.array(trustGateResultSchema),
     drift_detected: z.boolean(),

src/domain/electron/electronFuses.ts

@@ -64,19 +64,19 @@ const OTHER_MEANS_LIMITATION =
 const MISSING_SENTINEL_LIMITATION =
   "A missing sentinel means fuse state is unknown, not that every fuse is disabled.";
 
-const byteSchema = z.number().int().min(0).max(255);
+const byteSchema = z.int().min(0).max(255);
 const fuseStateSchema = z.enum(["enabled", "disabled", "removed", "unknown"]);
 
 /** One fuse byte, with a version-1 name when the pinned table covers its index. */
 export const electronFuseSchema = z.strictObject({
-  index: z.number().int().nonnegative(),
+  index: z.int().nonnegative(),
   name: z.string().min(1).nullable(),
   state: fuseStateSchema,
   raw_byte: byteSchema,
 });
 
 const electronFuseSentinelSchema = z.strictObject({
-  sentinel_offset: z.number().int().nonnegative(),
+  sentinel_offset: z.int().nonnegative(),
   wire_version: byteSchema.nullable(),
   declared_length: byteSchema.nullable(),
   fuses: z.array(electronFuseSchema),
@@ -84,18 +84,18 @@ const electronFuseSentinelSchema = z.strictObject({
 });
 
 const electronFuseSliceSchema = z.strictObject({
-  index: z.number().int().nonnegative(),
-  file_offset: z.number().int().nonnegative(),
-  size: z.number().int().nonnegative(),
+  index: z.int().nonnegative(),
+  file_offset: z.int().nonnegative(),
+  size: z.int().nonnegative(),
   architecture: z.string().min(1).nullable(),
-  sentinel_count: z.number().int().nonnegative(),
+  sentinel_count: z.int().nonnegative(),
   sentinels: z.array(electronFuseSentinelSchema),
 });
 
 const implicationLocation = {
   relationship: z.literal("derivation"),
-  slice_index: z.number().int().nonnegative(),
-  sentinel_offset: z.number().int().nonnegative(),
+  slice_index: z.int().nonnegative(),
+  sentinel_offset: z.int().nonnegative(),
 };
 
 /** Derived runtime meaning of one observed fuse byte. The fuse bytes stay observed. */
@@ -138,7 +138,7 @@ export const electronFuseReportSchema = z
         selected_path: localPathStringSchema,
         resolved_path: localPathStringSchema,
         sha256: digestSchema,
-        bytes: z.number().int().nonnegative(),
+        bytes: z.int().nonnegative(),
         format: z.enum(["mach-o", "mach-o-universal", "pe", "elf"]),
       })
       .describe(

src/domain/evidence.ts

@@ -104,12 +104,12 @@ export const evidenceLocationSchema = z.discriminatedUnion("kind", [
   z.strictObject({ kind: z.literal("artifact-path"), path: z.string().min(1) }),
   z.strictObject({
     kind: z.literal("file-offset"),
-    offset: z.number().int().min(0),
+    offset: z.int().min(0),
   }),
   z.strictObject({
     kind: z.literal("file-offset-range"),
-    start: z.number().int().min(0),
-    end: z.number().int().min(0),
+    start: z.int().min(0),
+    end: z.int().min(0),
   }),
 ]);
 

src/domain/evidenceCompletionLedger.ts

@@ -28,12 +28,12 @@ export const evidenceCompletionRecordSchema = z.strictObject({
 });
 
 const completionSummarySchema = z.strictObject({
-  total: z.number().int().min(1),
-  pass: z.number().int().nonnegative(),
-  fail: z.number().int().nonnegative(),
-  unsupported: z.number().int().nonnegative(),
-  truncated: z.number().int().nonnegative(),
-  unknown: z.number().int().nonnegative(),
+  total: z.int().min(1),
+  pass: z.int().nonnegative(),
+  fail: z.int().nonnegative(),
+  unsupported: z.int().nonnegative(),
+  truncated: z.int().nonnegative(),
+  unknown: z.int().nonnegative(),
   complete: z.boolean(),
 });
 

src/domain/evidenceRecordSummary.ts

@@ -14,7 +14,7 @@ export const evidenceRecordFiltersSchema = z.strictObject({
 });
 export type EvidenceRecordFilters = z.infer<typeof evidenceRecordFiltersSchema>;
 
-const countSchema = z.number().int().nonnegative();
+const countSchema = z.int().nonnegative();
 const nativeMetadataSchema = z.object({
   procedure: z.object({ address: z.string(), name: z.string().nullish() }),
   native_value_flow: z.unknown().optional(),

src/domain/evm/evmInterface.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { absoluteLocalPathStringSchema } from "../localPath.js";
 import { solidityMetadataSchema } from "./solidityMetadata.js";
 
-const byteOffset = z.number().int().nonnegative();
+const byteOffset = z.int().nonnegative();
 const sha256 = z.string().regex(/^[a-f0-9]{64}$/);
 /** Owned EVMole worker deadline. Omission keeps this value. */
 export const DEFAULT_EVM_TIMEOUT_MS = 30_000;

src/domain/evm/solidityMetadata.ts

@@ -30,8 +30,8 @@ export const solidityMetadataSchema = z
   .strictObject({
     profile: z.literal("terminal-cbor-scalars-v1"),
     status: z.enum(["unavailable", "decoded", "partial", "not-decoded"]),
-    bytecode_offset: z.number().int().nonnegative().nullable(),
-    cbor_bytes: z.number().int().positive().max(65535).nullable(),
+    bytecode_offset: z.int().nonnegative().nullable(),
+    cbor_bytes: z.int().positive().max(65535).nullable(),
     entries: z
       .array(
         z.strictObject({

src/domain/flutter/flutterBuildAnalysis.ts

@@ -89,7 +89,7 @@ export const flutterResultSchemas = {
   identify_flutter_build: z.strictObject({
     target: z.strictObject({
       path: localPathStringSchema,
-      bytes: z.number().int().nonnegative(),
+      bytes: z.int().nonnegative(),
       sha256: digestSchema,
     }),
     flutter_detected: z.boolean(),
@@ -98,12 +98,12 @@ export const flutterResultSchemas = {
         abi: z.string().min(1),
         libapp: z.strictObject({
           present: z.boolean(),
-          bytes: z.number().int().nonnegative().nullable(),
+          bytes: z.int().nonnegative().nullable(),
           sha256: digestSchema.nullable(),
           /** Supported ELF header with table extents inside the library; table contents are not validated. */
           elf_header_valid: z.boolean().nullable(),
           /** Number of Dart snapshot sections found (vm + isolate). */
-          snapshot_hash_sources: z.number().int().nonnegative(),
+          snapshot_hash_sources: z.int().nonnegative(),
           /** Distinct hashes found; more than one means the sections disagree. */
           snapshot_hash_candidates: z.array(
             z.string().regex(/^[0-9a-f]{32}$/u),
@@ -116,7 +116,7 @@ export const flutterResultSchemas = {
         }),
         libflutter: z.strictObject({
           present: z.boolean(),
-          bytes: z.number().int().nonnegative().nullable(),
+          bytes: z.int().nonnegative().nullable(),
           sha256: digestSchema.nullable(),
           build_id: z
             .string()
@@ -150,7 +150,7 @@ export const flutterResultSchemas = {
   inspect_dart_aot: z.strictObject({
     target: z.strictObject({
       path: localPathStringSchema,
-      bytes: z.number().int().nonnegative(),
+      bytes: z.int().nonnegative(),
       sha256: digestSchema,
     }),
     abi: z.string().min(1),
@@ -160,7 +160,7 @@ export const flutterResultSchemas = {
         .describe(
           "Coverage of ELF symbols, independent data headers, AOT kind, extents and agreeing hashes",
         ),
-      bytes: z.number().int().nonnegative(),
+      bytes: z.int().nonnegative(),
       sha256: digestSchema,
       snapshot_hash: z
         .string()
@@ -169,17 +169,17 @@ export const flutterResultSchemas = {
       /** Distinct hashes found; more than one means the sections disagree. */
       snapshot_hash_candidates: z.array(z.string().regex(/^[0-9a-f]{32}$/u)),
       /** Distinct exported data headers with a valid hash at the header's fixed offset. */
-      snapshot_hash_sources: z.number().int().nonnegative(),
+      snapshot_hash_sources: z.int().nonnegative(),
       /** Snapshot symbols read from the dynamic symbol table. */
       sections: z.array(
         z.strictObject({
           name: z.string().min(1),
-          offset: z.number().int().nonnegative(),
-          size: z.number().int().nonnegative(),
+          offset: z.int().nonnegative(),
+          size: z.int().nonnegative(),
           magic_valid: z.boolean(),
-          kind: z.number().int().nonnegative().nullable(),
+          kind: z.int().nonnegative().nullable(),
           /** Raw declared snapshot length, excluding the four magic bytes. */
-          header_length: z.number().int().nonnegative().nullable(),
+          header_length: z.int().nonnegative().nullable(),
         }),
       ),
     }),
@@ -191,14 +191,14 @@ export const flutterResultSchemas = {
         ),
       /** Distinct package: source URIs, sorted, bounded. */
       package_uris: z.array(z.string().min(1)),
-      package_uri_count_at_least: z.number().int().nonnegative(),
+      package_uri_count_at_least: z.int().nonnegative(),
       /** Distinct dart: SDK URIs, sorted, bounded. */
       dart_uris: z.array(z.string().min(1)),
-      dart_uri_count_at_least: z.number().int().nonnegative(),
+      dart_uri_count_at_least: z.int().nonnegative(),
       /** Identifier-like tokens, bounded; includes incidental matches. */
       class_like_tokens: z.array(z.string().min(1)),
-      class_like_token_count_at_least: z.number().int().nonnegative(),
-      printable_run_count: z.number().int().nonnegative(),
+      class_like_token_count_at_least: z.int().nonnegative(),
+      printable_run_count: z.int().nonnegative(),
     }),
     coverage: z.enum(["complete", "partial"]),
   }),

src/domain/functionComparisonSchemas.ts

@@ -24,15 +24,15 @@ export const functionComparisonInputSchema = z.strictObject({
 });
 
 const textDeltaSchema = z.object({
-  added_lines: z.number().int().min(0),
-  removed_lines: z.number().int().min(0),
-  hunks: z.number().int().min(0),
+  added_lines: z.int().min(0),
+  removed_lines: z.int().min(0),
+  hunks: z.int().min(0),
 });
 
 const functionDimensionContextShape = {
   dimension: functionComparisonDimensionNameSchema,
-  left_count: z.number().int().min(0).nullable(),
-  right_count: z.number().int().min(0).nullable(),
+  left_count: z.int().min(0).nullable(),
+  right_count: z.int().min(0).nullable(),
   evidence_links: z.array(evidenceIdSchema).min(2),
   limitations: z.array(z.string()),
 };
@@ -87,9 +87,9 @@ export const functionComparisonResultSchema = z
     left_subject_sha256: digestSchema,
     right_subject_sha256: digestSchema,
     summary: z.object({
-      unchanged: z.number().int().min(0),
-      changed: z.number().int().min(0),
-      unknown: z.number().int().min(0),
+      unchanged: z.int().min(0),
+      changed: z.int().min(0),
+      unknown: z.int().min(0),
     }),
     dimensions: z.array(functionDimensionSchema).length(8),
     changes: z.array(functionDimensionSchema),

src/domain/go/goBinary.ts

@@ -28,8 +28,8 @@ export const goArchitectureForSubject = (architecture: string) => {
 };
 
 const sourceRangeSchema = z.strictObject({
-  offset: z.number().int().nonnegative(),
-  bytes: z.number().int().nonnegative(),
+  offset: z.int().nonnegative(),
+  bytes: z.int().nonnegative(),
 });
 const moduleIdentitySchema = z.strictObject({
   path: z.string(),
@@ -69,7 +69,7 @@ export const inspectGoBinaryInputSchema = z.strictObject({
 
 /** Compiler-written build information and its original file-backed source ranges. */
 export const goBuildInfoSchema = z.strictObject({
-  header_offset: z.number().int().nonnegative(),
+  header_offset: z.int().nonnegative(),
   encoding: z.enum(["inline", "pointer"]),
   go_version: z.string().nullable(),
   go_version_bytes_base64: canonicalBase64Schema,
@@ -86,7 +86,7 @@ export const goBinarySchema = z
     artifact: z.strictObject({
       path: localPathStringSchema,
       sha256: digestSchema,
-      bytes: z.number().int().nonnegative(),
+      bytes: z.int().nonnegative(),
     }),
     format: z.enum(["elf", "pe", "macho"]),
     architecture: z.string(),

src/domain/hopperValues.ts

@@ -81,7 +81,7 @@ export const analysisStringSchema = z.object({
           "Whether the provider declares the encoding or REA infers it from the typed bytes and native display. This does not establish the original source's intended encoding.",
         ),
       termination: z.enum(["missing", "present_or_not_required"]),
-      byte_length: z.number().int().min(0),
+      byte_length: z.int().min(0),
     })
     .exactOptional(),
 });
@@ -106,13 +106,8 @@ export const functionBodySchema = z.discriminatedUnion("available", [
             .describe("Inclusive last address of this observed body range."),
         }),
       ),
-      total_bytes: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-      span_bytes: z
-        .number()
-        .int()
-        .min(0)
-        .max(Number.MAX_SAFE_INTEGER)
-        .nullable(),
+      total_bytes: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
+      span_bytes: z.int().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
       non_contiguous: z.boolean(),
       contains_entry: z.boolean(),
     })
@@ -266,7 +261,7 @@ export const availableReferenceKindSchema = z
     conditional: z.boolean(),
     terminal: z.boolean(),
     primary: z.boolean(),
-    operand_index: z.number().int(),
+    operand_index: z.int(),
     external: z.boolean(),
   })
   .strict();
@@ -317,7 +312,7 @@ export const swiftStringLiteralSchema = z.discriminatedUnion("representation", [
 
 const swiftStringLiteralOmissionFields = {
   source_address: swiftStringLiteralFields.source_address,
-  byte_length: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  byte_length: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
   reason: z
     .enum(["capacity", "unresolved_jump"])
     .describe(

src/domain/javascript/electronActiveObservation.ts

@@ -12,7 +12,7 @@ const absolutePathSchema = z
     "provider path must be absolute",
   );
 
-const windowIndexSchema = z.number().int().min(0);
+const windowIndexSchema = z.int().min(0);
 
 const deepLinkUrlSchema = z
   .string()
@@ -37,7 +37,7 @@ const actionSchema = z.discriminatedUnion("kind", [
   z.strictObject({
     step_id: z.string().min(1),
     kind: z.literal("wait"),
-    duration_ms: z.number().int().min(0),
+    duration_ms: z.int().min(0),
     window_index: windowIndexSchema.optional(),
   }),
   z.strictObject({
@@ -86,7 +86,7 @@ export type ElectronActiveObservationInput = z.infer<
 
 /** Canonical active Electron event shared by the hook boundary and public timeline. */
 export const electronActiveTimelineEventSchema = z.strictObject({
-  sequence: z.number().int().min(1),
+  sequence: z.int().min(1),
   correlation_id: z.string().nullable(),
   kind: z.enum([
     "main-handler-invocation",
@@ -158,7 +158,7 @@ const ipcEventSchema = electronActiveTimelineEventSchema.extend({
 
 /** Process facts shared by the runtime boundary and retained active observation. */
 export const electronActiveProcessMetricSchema = z.strictObject({
-  pid: z.number().int().min(1),
+  pid: z.int().min(1),
   type: z.string().min(1),
   name: z.string().nullable(),
   service_name: z.string().nullable(),
@@ -199,7 +199,7 @@ const actionResultContextShape = {
   ]),
   window_index: windowIndexSchema.nullable(),
   target: z.string().nullable(),
-  elapsed_ms: z.number().int().min(0),
+  elapsed_ms: z.int().min(0),
 };
 
 const actionResultSchema = z.discriminatedUnion("status", [
@@ -231,36 +231,36 @@ export const electronActiveObservationResultSchema = z.strictObject({
   }),
   ipc: z.strictObject({
     events: z.array(ipcEventSchema),
-    observed: z.number().int().min(0),
-    dropped: z.number().int().min(0),
+    observed: z.int().min(0),
+    dropped: z.int().min(0),
   }),
   timeline: z.strictObject({
     events: z.array(electronActiveTimelineEventSchema),
-    observed: z.number().int().min(0),
-    dropped: z.number().int().min(0),
+    observed: z.int().min(0),
+    dropped: z.int().min(0),
   }),
   retention: z.strictObject({
-    budget_bytes: z.number().int().min(0),
-    estimated_retained_bytes: z.number().int().min(0),
-    event_serialized_byte_upper_bound: z.number().int().min(0),
-    retained: z.number().int().min(0),
-    dropped: z.number().int().min(0),
+    budget_bytes: z.int().min(0),
+    estimated_retained_bytes: z.int().min(0),
+    event_serialized_byte_upper_bound: z.int().min(0),
+    retained: z.int().min(0),
+    dropped: z.int().min(0),
     dropped_event_families: z.array(
       z.strictObject({
         family: z.string().min(1),
-        count: z.number().int().min(1),
+        count: z.int().min(1),
       }),
     ),
     dropped_event_roles: z.array(
       z.strictObject({
         role: z.string().min(1),
-        count: z.number().int().min(1),
+        count: z.int().min(1),
       }),
     ),
-    observed_ipc: z.number().int().min(0),
-    dropped_ipc: z.number().int().min(0),
-    observed_runtime: z.number().int().min(0),
-    dropped_runtime: z.number().int().min(0),
+    observed_ipc: z.int().min(0),
+    dropped_ipc: z.int().min(0),
+    observed_runtime: z.int().min(0),
+    dropped_runtime: z.int().min(0),
   }),
   coverage: coverageSchema,
   limitations: z.array(z.string()),

src/domain/javascript/electronObservation.ts

@@ -27,7 +27,7 @@ export type ListElectronTargetsInput = z.infer<
 const inspectElectronPageFacts = {
   ...approvedElectronInput,
   target_id: z.string().trim().min(1),
-  observation_ms: z.number().int().min(0).default(100),
+  observation_ms: z.int().min(0).default(100),
   command_timeout_ms: webRuntimeCommandTimeoutSchema,
 } as const;
 export const inspectElectronPageInputSchema = z.union([
@@ -62,8 +62,8 @@ export const electronTargetListSchema = z.object({
   browser: browserVersionSchema,
   targets: z.array(electronTargetSchema),
   excluded: z.object({
-    unsupported_url: z.number().int().min(0),
-    non_page: z.number().int().min(0),
+    unsupported_url: z.int().min(0),
+    non_page: z.int().min(0),
   }),
   limitations: z.array(z.string()),
 });
@@ -76,7 +76,7 @@ export const electronPageInspectionSchema = z.object({
   capture_window: z.object({
     started_at: z.iso.datetime(),
     ended_at: z.iso.datetime(),
-    observation_ms: z.number().int().min(0),
+    observation_ms: z.int().min(0),
   }),
   completeness: browserCompletenessSchema,
   frames: z.array(
@@ -87,11 +87,11 @@ export const electronPageInspectionSchema = z.object({
     }),
   ),
   dom: z.object({
-    total_nodes: z.number().int().min(0),
+    total_nodes: z.int().min(0),
     nodes: z.array(cdpDomNodeSchema),
   }),
   scripts: z.object({
-    total: z.number().int().min(0),
+    total: z.int().min(0),
     items: z.array(
       z.object({
         script_key: prefixedDigestSchema("electron_script"),

src/domain/javascript/javascriptApplicationAnalysis.ts

@@ -22,7 +22,7 @@ import {
   javaScriptSourceSelectionSchema,
 } from "./javascriptSourceSelection.js";
 
-const countSchema = z.number().int().min(0);
+const countSchema = z.int().min(0);
 
 /** Public target-free request for static JavaScript application analysis. */
 export const analyzeJavaScriptApplicationInputSchema = z.strictObject({

src/domain/javascript/javascriptApplicationEvidenceSchemas.ts

@@ -96,8 +96,8 @@ const sourceRangeSchema = javascriptSourceRangeSchema.safeExtend({
 const fileOffsetRangeSchema = z
   .strictObject({
     kind: z.literal("file-offset-range"),
-    start: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-    end: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    start: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
+    end: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
   })
   .superRefine((location, context) => {
     if (location.end < location.start)
@@ -158,7 +158,7 @@ const applicationExtractorSchema = z.strictObject({
 
 const applicationLimitSchema = z.strictObject({
   name: z.string().min(1),
-  value: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  value: z.int().min(0).max(Number.MAX_SAFE_INTEGER),
   unit: z.enum([
     "items",
     "bytes",
@@ -172,7 +172,7 @@ const applicationLimitSchema = z.strictObject({
 
 /** Bounded collection coverage without treating omission as absence. */
 const coverageLimitsSchema = z.array(applicationLimitSchema);
-const omittedCountSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const omittedCountSchema = z.int().min(0).max(Number.MAX_SAFE_INTEGER);
 
 export const applicationCoverageSchema = z.union([
   z.strictObject({

src/domain/javascript/javascriptApplicationVersionComparisonSchemas.ts

@@ -183,8 +183,8 @@ const comparisonItemSchema = z.union([
 const comparisonCoverageSchema = z.strictObject({
   left_graph_status: z.enum(["complete", "partial", "unknown", "unavailable"]),
   right_graph_status: z.enum(["complete", "partial", "unknown", "unavailable"]),
-  left_graph_omitted_count: z.number().int().min(0).nullable(),
-  right_graph_omitted_count: z.number().int().min(0).nullable(),
+  left_graph_omitted_count: z.int().min(0).nullable(),
+  right_graph_omitted_count: z.int().min(0).nullable(),
   status: z.enum(["complete-within-inputs", "partial", "truncated"]),
 });
 
@@ -203,21 +203,21 @@ export const applicationVersionComparisonResultSchema = z
       root_artifact_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     }),
     summary: z.strictObject({
-      unchanged: z.number().int().min(0),
-      added: z.number().int().min(0),
-      removed: z.number().int().min(0),
-      changed: z.number().int().min(0),
-      unknown: z.number().int().min(0),
+      unchanged: z.int().min(0),
+      added: z.int().min(0),
+      removed: z.int().min(0),
+      changed: z.int().min(0),
+      unknown: z.int().min(0),
     }),
     matching: z.strictObject({
-      exact_node_identity: z.number().int().min(0),
-      exact_content_digest: z.number().int().min(0),
-      exact_module_source_digest: z.number().int().min(0),
-      source_map_identity: z.number().int().min(0),
-      structural_fingerprint: z.number().int().min(0),
-      semantic_key: z.number().int().min(0),
-      ambiguous: z.number().int().min(0),
-      unmatched: z.number().int().min(0),
+      exact_node_identity: z.int().min(0),
+      exact_content_digest: z.int().min(0),
+      exact_module_source_digest: z.int().min(0),
+      source_map_identity: z.int().min(0),
+      structural_fingerprint: z.int().min(0),
+      semantic_key: z.int().min(0),
+      ambiguous: z.int().min(0),
+      unmatched: z.int().min(0),
     }),
     items: z.array(comparisonItemSchema),
     graph: javascriptApplicationGraphSchema,

src/domain/javascript/javascriptExportShapeComparisonSchemas.ts

@@ -106,7 +106,7 @@ const projectedPropertyCoverageSchema = z.discriminatedUnion("status", [
   z.strictObject({
     path: jsonPointerSchema,
     status: z.literal("partial"),
-    omitted: z.union([z.number().int().positive(), z.null()]),
+    omitted: z.union([z.int().positive(), z.null()]),
   }),
 ]);
 export type ProjectedPropertyCoverage = z.infer<
@@ -156,10 +156,10 @@ export const projectedExportReturnShapesSchema = z
     static_return_shapes: z.array(projectedReturnShapeSchema),
     return_shape_coverage: z.strictObject({
       status: z.enum(["complete", "partial", "truncated"]),
-      retained_return_sites: z.number().int().min(0),
-      omitted_return_sites: z.number().int().min(0).nullable(),
-      omitted_fields: z.number().int().min(0),
-      omitted_property_coverage: z.number().int().min(0),
+      retained_return_sites: z.int().min(0),
+      omitted_return_sites: z.int().min(0).nullable(),
+      omitted_fields: z.int().min(0),
+      omitted_property_coverage: z.int().min(0),
       projection_complete: z.boolean(),
     }),
   })
@@ -189,7 +189,7 @@ const selectorResultShape = {
   requested_module_path: textSchema,
   requested_export_name: exportNameSchema,
   candidates: z.array(exportCandidateSchema),
-  omitted_candidates: z.number().int().min(0),
+  omitted_candidates: z.int().min(0),
 };
 const selectorResultSchema = z.union([
   z.strictObject({
@@ -261,7 +261,7 @@ const inventoryPropertyCoverageSchema = z.strictObject({
 
 const propertyInventorySchema = z.strictObject({
   side: z.enum(["left", "right"]),
-  variant_index: z.number().int().nonnegative(),
+  variant_index: z.int().nonnegative(),
   discriminant: discriminantSchema.nullable(),
   paired: z.boolean(),
   source_range: javascriptSourceRangeSchema,
@@ -276,10 +276,10 @@ export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
   right: selectorResultSchema,
   property_inventories: z.array(propertyInventorySchema),
   summary: z.strictObject({
-    added: z.number().int().min(0),
-    removed: z.number().int().min(0),
-    changed: z.number().int().min(0),
-    unknown: z.number().int().min(0),
+    added: z.int().min(0),
+    removed: z.int().min(0),
+    changed: z.int().min(0),
+    unknown: z.int().min(0),
   }),
   changes: z.array(javaScriptExportShapeComparisonChangeSchema),
   coverage: z.strictObject({
@@ -296,19 +296,19 @@ export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
       "unknown",
       "unavailable",
     ]),
-    paired_variants: z.number().int().min(0),
-    unpaired_left_variants: z.number().int().min(0),
-    unpaired_right_variants: z.number().int().min(0),
-    omitted_left_variants: z.number().int().min(0),
-    omitted_right_variants: z.number().int().min(0),
-    left_source_omitted_variants: z.number().int().min(0).nullable(),
-    right_source_omitted_variants: z.number().int().min(0).nullable(),
-    left_omitted_fields: z.number().int().min(0),
-    right_omitted_fields: z.number().int().min(0),
-    left_omitted_property_coverage: z.number().int().min(0),
-    right_omitted_property_coverage: z.number().int().min(0),
-    omitted_candidates: z.number().int().min(0),
-    omitted_changes: z.number().int().min(0),
+    paired_variants: z.int().min(0),
+    unpaired_left_variants: z.int().min(0),
+    unpaired_right_variants: z.int().min(0),
+    omitted_left_variants: z.int().min(0),
+    omitted_right_variants: z.int().min(0),
+    left_source_omitted_variants: z.int().min(0).nullable(),
+    right_source_omitted_variants: z.int().min(0).nullable(),
+    left_omitted_fields: z.int().min(0),
+    right_omitted_fields: z.int().min(0),
+    left_omitted_property_coverage: z.int().min(0),
+    right_omitted_property_coverage: z.int().min(0),
+    omitted_candidates: z.int().min(0),
+    omitted_changes: z.int().min(0),
   }),
   evidence_links: z.array(evidenceIdSchema).length(2),
   limitations: z.array(textSchema),

src/domain/javascript/javascriptFeatureTraceSchemas.ts

@@ -161,15 +161,15 @@ export const applicationFeatureTraceResultSchema = z.strictObject({
   paths: z.array(tracePathSchema),
   native_handoffs: z.array(nativeHandoffSchema),
   summary: z.strictObject({
-    matched_seeds: z.number().int().min(0),
-    traced_nodes: z.number().int().min(0),
-    traced_edges: z.number().int().min(0),
-    terminal_paths: z.number().int().min(0),
-    native_handoffs: z.number().int().min(0),
-    observed_facts: z.number().int().min(0),
-    inferred_facts: z.number().int().min(0),
-    unknown_facts: z.number().int().min(0),
-    unavailable_facts: z.number().int().min(0),
+    matched_seeds: z.int().min(0),
+    traced_nodes: z.int().min(0),
+    traced_edges: z.int().min(0),
+    terminal_paths: z.int().min(0),
+    native_handoffs: z.int().min(0),
+    observed_facts: z.int().min(0),
+    inferred_facts: z.int().min(0),
+    unknown_facts: z.int().min(0),
+    unavailable_facts: z.int().min(0),
   }),
   coverage: z.strictObject({
     status: z.enum(["complete-within-source", "partial", "no-match"]),
@@ -179,7 +179,7 @@ export const applicationFeatureTraceResultSchema = z.strictObject({
       "unknown",
       "unavailable",
     ]),
-    total_seed_matches: z.number().int().min(0),
+    total_seed_matches: z.int().min(0),
   }),
   evidence_links: z.array(evidenceIdSchema).min(1),
   limitations: z.array(boundedTextSchema),

src/domain/javascript/javascriptRecovery.ts

@@ -35,12 +35,12 @@ export const javascriptRecoveryInputSchema = z.strictObject({
 const fileSchema = z.strictObject({
   path: z.string().min(1),
   sha256: digestSchema,
-  bytes: z.number().int().nonnegative(),
+  bytes: z.int().nonnegative(),
 });
 
 const rangeSchema = z.strictObject({
-  start: z.number().int().nonnegative(),
-  end: z.number().int().nonnegative(),
+  start: z.int().nonnegative(),
+  end: z.int().nonnegative(),
 });
 
 const sourceSchema = fileSchema.extend({
@@ -70,8 +70,8 @@ export const javascriptRecoveryResultSchema = z.strictObject({
   reported_safety: z.string(),
   reported_strategy: z.string(),
   reported_format: z.string(),
-  total: z.number().int().nonnegative(),
-  failed: z.number().int().nonnegative(),
+  total: z.int().nonnegative(),
+  failed: z.int().nonnegative(),
   modules: z.array(
     z.strictObject({
       reported_filename: z.string().min(1),

src/domain/javascript/javascriptRuntimeObservation.ts

@@ -32,7 +32,7 @@ export const observeJavaScriptRuntimeInputSchema = z.strictObject({
   ...runtimeEndpoint,
   target_id: z.string().trim().min(1),
   runtime_kind: javascriptRuntimeKindSchema.optional(),
-  observation_ms: z.number().int().min(0).default(100),
+  observation_ms: z.int().min(0).default(100),
 });
 export type ObserveJavaScriptRuntimeInput = z.infer<
   typeof observeJavaScriptRuntimeInputSchema
@@ -103,8 +103,8 @@ export const javascriptRuntimeTargetListSchema = z.strictObject({
   runtime: javascriptRuntimeVersionSchema,
   targets: z.array(javascriptRuntimeTargetSchema),
   excluded: z.strictObject({
-    unsupported_location: z.number().int().min(0),
-    unconnectable: z.number().int().min(0),
+    unsupported_location: z.int().min(0),
+    unconnectable: z.int().min(0),
   }),
   limitations: z.array(observationTextSchema),
 });
@@ -118,7 +118,6 @@ const javascriptRuntimeScriptSchema = z.strictObject({
   execution_context_key: z.string().nullable(),
   cdp_hash: z.string().nullable(),
   length: z
-    .number()
     .int()
     .min(0)
     .nullable()
@@ -150,20 +149,20 @@ export const javascriptRuntimeObservationSchema = z.strictObject({
     ]),
   }),
   capture: z.strictObject({
-    observation_ms: z.number().int().min(0),
-    events_observed: z.number().int().min(0),
-    events_retained: z.number().int().min(0),
-    events_dropped: z.number().int().min(0),
-    metadata_bytes_retained: z.number().int().min(0),
+    observation_ms: z.int().min(0),
+    events_observed: z.int().min(0),
+    events_retained: z.int().min(0),
+    events_dropped: z.int().min(0),
+    metadata_bytes_retained: z.int().min(0),
     truncated: z.boolean(),
     truncation_reasons: z.array(observationTextSchema),
   }),
   scripts: z.strictObject({
     items: z.array(javascriptRuntimeScriptSchema),
-    observed_total: z.number().int().min(0),
+    observed_total: z.int().min(0),
     excluded: z.strictObject({
-      unsupported_location: z.number().int().min(0),
-      invalid_protocol_value: z.number().int().min(0),
+      unsupported_location: z.int().min(0),
+      invalid_protocol_value: z.int().min(0),
     }),
   }),
   execution_contexts: z.array(javascriptRuntimeContextSchema),

src/domain/javascript/javascriptRuntimeReconciliationSchemas.ts

@@ -152,9 +152,9 @@ const captureSummarySchema = z.strictObject({
     .string()
     .min(1)
     .or(javascriptRuntimeUnresolvedLocationSchema),
-  frames: z.number().int().min(0),
-  scripts: z.number().int().min(0),
-  workers: z.number().int().min(0),
+  frames: z.int().min(0),
+  scripts: z.int().min(0),
+  workers: z.int().min(0),
   scripts_complete_within_scope: z.boolean(),
 });
 
@@ -188,7 +188,7 @@ const reconciliationItemShape = {
   ]),
   confidence: z.enum(["exact", "high", "medium", "low", "unknown"]),
   reason: reconciliationReasonSchema,
-  candidate_static_count: z.number().int().min(0),
+  candidate_static_count: z.int().min(0),
   candidate_static_nodes: z.array(
     z.strictObject({
       static_layer_id: prefixedDigestSchema("jrl"),
@@ -239,34 +239,34 @@ export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
   runtime_captures: z.array(captureSummarySchema).min(1),
   graph: javascriptApplicationGraphSchema,
   summary: z.strictObject({
-    runtime_targets: z.number().int().min(0),
-    runtime_frames: z.number().int().min(0),
-    runtime_scripts: z.number().int().min(0),
-    runtime_workers: z.number().int().min(0),
-    matched: z.number().int().min(0),
-    ambiguous: z.number().int().min(0),
-    unmatched: z.number().int().min(0),
-    unknown: z.number().int().min(0),
-    static_loaded: z.number().int().min(0),
-    static_resident: z.number().int().min(0),
-    static_not_observed: z.number().int().min(0),
-    static_unknown: z.number().int().min(0),
+    runtime_targets: z.int().min(0),
+    runtime_frames: z.int().min(0),
+    runtime_scripts: z.int().min(0),
+    runtime_workers: z.int().min(0),
+    matched: z.int().min(0),
+    ambiguous: z.int().min(0),
+    unmatched: z.int().min(0),
+    unknown: z.int().min(0),
+    static_loaded: z.int().min(0),
+    static_resident: z.int().min(0),
+    static_not_observed: z.int().min(0),
+    static_unknown: z.int().min(0),
   }),
   reconciliations: z.array(reconciliationItemSchema),
   static_load_states: z.array(staticLoadStateSchema),
   source_map_authority: z.strictObject({
     used_for_primary_matching: z.literal(false),
-    static_layer_count: z.number().int().min(0),
-    runtime_script_declarations: z.number().int().min(0),
+    static_layer_count: z.int().min(0),
+    runtime_script_declarations: z.int().min(0),
     limitation: boundedTextSchema,
   }),
   coverage: z.strictObject({
     status: z.enum(["complete-within-inputs", "partial", "truncated"]),
     truncated: z.boolean(),
-    omitted_runtime_entities: z.number().int().min(0),
-    omitted_reconciliation_items: z.number().int().min(0),
-    omitted_static_load_states: z.number().int().min(0),
-    omitted_graph_items: z.number().int().min(0),
+    omitted_runtime_entities: z.int().min(0),
+    omitted_reconciliation_items: z.int().min(0),
+    omitted_static_load_states: z.int().min(0),
+    omitted_graph_items: z.int().min(0),
   }),
   evidence_links: z.array(evidenceIdSchema).min(2),
   limitations: z.array(boundedTextSchema),

src/domain/javascript/javascriptSemanticGraphSchemas.ts

@@ -257,7 +257,7 @@ export const JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS = [
 export const javaScriptSemanticUnknownOmissionSchema = z.strictObject({
   family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
   reason: z.enum(JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS),
-  occurrences: z.number().int().positive(),
+  occurrences: z.int().positive(),
 });
 /** At most one summary row for each finite family/reason pair. */
 export const javaScriptSemanticUnknownOmissionsSchema = z
@@ -290,7 +290,7 @@ export const javaScriptSemanticUnknownSchema =
   });
 
 const fingerprintComponentsSchema = z.strictObject({
-  parameter_arity: z.number().int().min(0),
+  parameter_arity: z.int().min(0),
   normalized_ast_sha256: digestSchema,
   control_flow_sha256: digestSchema,
   relation_shape_sha256: digestSchema,
@@ -329,8 +329,8 @@ export const javaScriptSemanticFingerprintSchema =
 const familyCoverageSchema = z.strictObject({
   family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
   status: z.enum(["complete", "partial", "unknown", "unsupported"]),
-  retained_relations: z.number().int().min(0),
-  omitted_relations: z.number().int().min(0).nullable(),
+  retained_relations: z.int().min(0),
+  omitted_relations: z.int().min(0).nullable(),
   unknown_ids: z.array(semanticUnknownIdSchema),
 });
 
@@ -339,12 +339,12 @@ const graphCoverageSchema = z.strictObject({
   truncated: z.boolean(),
   omitted_unknown_occurrences:
     javaScriptSemanticUnknownOmissionsSchema.exactOptional(),
-  omitted_nodes: z.number().int().min(0).nullable(),
-  omitted_relations: z.number().int().min(0).nullable(),
+  omitted_nodes: z.int().min(0).nullable(),
+  omitted_relations: z.int().min(0).nullable(),
   limits: z.array(
     z.strictObject({
       name: z.string().min(1),
-      value: z.number().int().min(0),
+      value: z.int().min(0),
       unit: z.enum(["items", "bytes", "milliseconds", "depth", "other"]),
     }),
   ),

src/domain/javascript/javascriptSemanticQuerySchemas.ts

@@ -94,12 +94,12 @@ export const javaScriptSemanticQueryResultSchema = z.strictObject({
   unknowns: z.array(javaScriptSemanticUnknownSchema),
   expected_match_node_ids: z.array(semanticNodeIdSchema),
   summary: z.strictObject({
-    total_seed_matches: z.number().int().min(0),
-    traversed_nodes: z.number().int().min(0),
-    traversed_relations: z.number().int().min(0),
-    traversed_functions: z.number().int().min(0),
-    traversed_modules: z.number().int().min(0),
-    relevant_unknowns: z.number().int().min(0),
+    total_seed_matches: z.int().min(0),
+    traversed_nodes: z.int().min(0),
+    traversed_relations: z.int().min(0),
+    traversed_functions: z.int().min(0),
+    traversed_modules: z.int().min(0),
+    relevant_unknowns: z.int().min(0),
   }),
   coverage: z.strictObject({
     status: z.enum(["complete", "partial", "unavailable"]),

src/domain/javascript/javascriptSourceSelection.ts

@@ -11,7 +11,7 @@ export const javaScriptSourcePathsSchema = z
 /** Caller scope retained independently of analysis success or completeness. */
 export const javaScriptSourceSelectionSchema = z.strictObject({
   requested_paths: javaScriptSourcePathsSchema,
-  unselected_files: z.number().int().min(0),
+  unselected_files: z.int().min(0),
 });
 
 /** Explicit selected-source boundary for an otherwise complete inventory. */

src/domain/javascript/sourceToBundleComparisonSchemas.ts

@@ -38,7 +38,7 @@ export const compareSourceToBundleInputSchema = z.strictObject({
 
 const sourceToBundleSignalSchema = z.strictObject({
   kind: sourceToBundleSignalKindSchema,
-  weight: z.number().int().min(1).max(100),
+  weight: z.int().min(1).max(100),
   source_value: textSchema,
   current_values: z.array(textSchema).min(1),
 });
@@ -46,7 +46,7 @@ const sourceToBundleSignalSchema = z.strictObject({
 const sourceToBundleCandidateSchema = z.strictObject({
   current_node_id: nodeIdSchema,
   current_node_kind: z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS),
-  score: z.number().int().min(1),
+  score: z.int().min(1),
   confidence: z.enum(["exact", "high", "medium", "low"]),
   signals: z.array(sourceToBundleSignalSchema).min(1),
 });
@@ -89,18 +89,18 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
     weights: z.array(
       z.strictObject({
         signal: sourceToBundleSignalKindSchema,
-        weight: z.number().int().min(1).max(100),
+        weight: z.int().min(1).max(100),
       }),
     ),
   }),
   summary: z.strictObject({
-    unchanged: z.number().int().min(0),
-    modified: z.number().int().min(0),
-    removed: z.number().int().min(0),
-    split: z.number().int().min(0),
-    merged: z.number().int().min(0),
-    duplicated: z.number().int().min(0),
-    unknown: z.number().int().min(0),
+    unchanged: z.int().min(0),
+    modified: z.int().min(0),
+    removed: z.int().min(0),
+    split: z.int().min(0),
+    merged: z.int().min(0),
+    duplicated: z.int().min(0),
+    unknown: z.int().min(0),
   }),
   items: z.array(sourceToBundleItemSchema),
   unmapped_current_node_ids: z.array(nodeIdSchema),
@@ -113,9 +113,9 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
       "unknown",
       "unavailable",
     ]),
-    retained_source_files: z.number().int().min(0),
-    retained_application_nodes: z.number().int().min(0),
-    candidate_evaluations: z.number().int().min(0),
+    retained_source_files: z.int().min(0),
+    retained_application_nodes: z.int().min(0),
+    candidate_evaluations: z.int().min(0),
   }),
   evidence_links: z.array(evidenceIdSchema).length(1),
   limitations: z.array(textSchema),

src/domain/jsonShape.ts

@@ -22,13 +22,13 @@ type JsonShapePathSegment = z.infer<typeof jsonShapePathSegmentSchema>;
 /** Value-free structural summary of one approved JSON payload. */
 export const jsonShapeSchema = z.object({
   root_type: jsonValueTypeSchema,
-  node_count: z.number().int().min(1),
-  max_depth_observed: z.number().int().min(0),
+  node_count: z.int().min(1),
+  max_depth_observed: z.int().min(0),
   properties: z.array(
     z.object({
       path: z.array(jsonShapePathSegmentSchema).min(1),
       types: z.array(jsonValueTypeSchema).min(1),
-      observations: z.number().int().min(1),
+      observations: z.int().min(1),
     }),
   ),
 });

src/domain/managed/managedApplicationGraph.ts

@@ -66,15 +66,15 @@ export const managedApplicationGraphResultSchema = z.strictObject({
     managed_native_boundaries_evidence_id: evidenceIdSchema.nullable(),
   }),
   summary: z.strictObject({
-    graph_nodes: z.number().int().min(0),
-    graph_edges: z.number().int().min(0),
-    assemblies: z.number().int().min(0),
-    modules: z.number().int().min(0),
-    types: z.number().int().min(0),
-    methods: z.number().int().min(0),
-    fields: z.number().int().min(0),
-    pinvoke_imports: z.number().int().min(0),
-    native_implementations: z.number().int().min(0),
+    graph_nodes: z.int().min(0),
+    graph_edges: z.int().min(0),
+    assemblies: z.int().min(0),
+    modules: z.int().min(0),
+    types: z.int().min(0),
+    methods: z.int().min(0),
+    fields: z.int().min(0),
+    pinvoke_imports: z.int().min(0),
+    native_implementations: z.int().min(0),
   }),
   graph: javascriptApplicationGraphSchema,
   coverage: z.strictObject({

src/domain/managed/managedArtifact.ts

@@ -3,7 +3,7 @@ import { digestSchema } from "../digests.js";
 
 /** Build-local ECMA-335 metadata token emitted as an eight-digit lowercase hex value. */
 export const managedMetadataTokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
-const offsetSchema = z.number().int().min(0);
+const offsetSchema = z.int().min(0);
 
 /** A 16-byte CLI metadata GUID without RFC 4122 version/variant restrictions. */
 export const cliMetadataGuidSchema = z
@@ -12,7 +12,7 @@ export const cliMetadataGuidSchema = z
 
 const publicKeyIdentitySchema = z.object({
   kind: z.enum(["none", "public-key", "public-key-token"]),
-  byte_length: z.number().int().min(0),
+  byte_length: z.int().min(0),
   sha256: digestSchema.nullable(),
   token: z
     .string()
@@ -24,8 +24,8 @@ const assemblyIdentitySchema = z.object({
   name: z.string(),
   version: z.string().regex(/^\d+\.\d+\.\d+\.\d+$/u),
   culture: z.string().nullable(),
-  flags: z.number().int().min(0).max(0xffff_ffff),
-  hash_algorithm: z.number().int().min(0).max(0xffff_ffff),
+  flags: z.int().min(0).max(0xffff_ffff),
+  hash_algorithm: z.int().min(0).max(0xffff_ffff),
   public_key: publicKeyIdentitySchema,
   token: managedMetadataTokenSchema,
   row_offset: offsetSchema,
@@ -33,7 +33,7 @@ const assemblyIdentitySchema = z.object({
 
 const moduleIdentitySchema = z.object({
   name: z.string(),
-  generation: z.number().int().min(0).max(0xffff),
+  generation: z.int().min(0).max(0xffff),
   mvid: cliMetadataGuidSchema.nullable(),
   enc_id: cliMetadataGuidSchema.nullable(),
   enc_base_id: cliMetadataGuidSchema.nullable(),
@@ -44,17 +44,14 @@ const moduleIdentitySchema = z.object({
 const managedArtifactReferenceSchema = z.object({
   path: z.string().min(1),
   sha256: digestSchema,
-  byte_length: z.number().int().min(0),
+  byte_length: z.int().min(0),
   format: z.literal("pe"),
 });
 
 const managedMetadataSummarySchema = z.object({
   status: z.enum(["absent", "complete", "partial", "malformed"]),
   version: z.string().nullable(),
-  table_row_counts: z.record(
-    z.string(),
-    z.number().int().min(0).max(0xffff_ffff),
-  ),
+  table_row_counts: z.record(z.string(), z.int().min(0).max(0xffff_ffff)),
 });
 
 const managedTokenIdentityScopeSchema = z.object({
@@ -67,22 +64,22 @@ const assemblyReferenceSchema = z.object({
   name: z.string(),
   version: z.string().regex(/^\d+\.\d+\.\d+\.\d+$/u),
   culture: z.string().nullable(),
-  flags: z.number().int().min(0).max(0xffff_ffff),
+  flags: z.int().min(0).max(0xffff_ffff),
   public_key_or_token: publicKeyIdentitySchema,
   hash_value_sha256: digestSchema.nullable(),
-  hash_value_length: z.number().int().min(0),
+  hash_value_length: z.int().min(0),
   token: managedMetadataTokenSchema,
   row_offset: offsetSchema,
 });
 
 const managedResourceSchema = z.object({
   name: z.string(),
-  flags: z.number().int().min(0).max(0xffff_ffff),
+  flags: z.int().min(0).max(0xffff_ffff),
   visibility: z.enum(["public", "private", "unknown"]),
   implementation_token: managedMetadataTokenSchema.nullable(),
   embedded: z.boolean(),
-  declared_offset: z.number().int().min(0).max(0xffff_ffff),
-  data_length: z.number().int().min(0).nullable(),
+  declared_offset: z.int().min(0).max(0xffff_ffff),
+  data_length: z.int().min(0).nullable(),
   data_sha256: digestSchema.nullable(),
   token: managedMetadataTokenSchema,
   row_offset: offsetSchema,
@@ -92,7 +89,7 @@ const customAttributeSchema = z.object({
   parent_token: managedMetadataTokenSchema,
   constructor_token: managedMetadataTokenSchema.nullable(),
   type_name: z.string().nullable(),
-  value_length: z.number().int().min(0),
+  value_length: z.int().min(0),
   value_sha256: digestSchema,
   decoded_fixed_string: z.string().nullable(),
   token: managedMetadataTokenSchema,
@@ -100,7 +97,7 @@ const customAttributeSchema = z.object({
 });
 
 const managedSignatureSchema = z.object({
-  raw_length: z.number().int().min(0),
+  raw_length: z.int().min(0),
   raw_sha256: digestSchema,
   // Evidence recorded before this field existed reads back as null.
   resolved_sha256: digestSchema
@@ -112,8 +109,8 @@ const managedSignatureSchema = z.object({
   kind: z.enum(["method", "field", "unknown"]),
   parse_status: z.enum(["decoded", "partial", "unsupported", "malformed"]),
   calling_convention: z.string().nullable(),
-  generic_parameter_count: z.number().int().min(0).nullable(),
-  parameter_count: z.number().int().min(0).nullable(),
+  generic_parameter_count: z.int().min(0).nullable(),
+  parameter_count: z.int().min(0).nullable(),
   return_type: z.string().nullable(),
   parameter_types: z.array(z.string()),
   field_type: z.string().nullable(),
@@ -132,7 +129,7 @@ const managedTypeSchema = z.object({
     .describe(
       "Framed nominal namespace/name/enclosing-name digest, independent of build-local rows. Null for historical Evidence or unresolved nesting; defining assemblies and CLR runtime identity are not established.",
     ),
-  flags: z.number().int().min(0).max(0xffff_ffff),
+  flags: z.int().min(0).max(0xffff_ffff),
   extends_token: managedMetadataTokenSchema.nullable(),
   enclosing_type_token: managedMetadataTokenSchema
     .nullable()
@@ -141,14 +138,14 @@ const managedTypeSchema = z.object({
       "Observed enclosing TypeDef from NestedClass; null when no enclosing entry was available, which alone does not establish top-level identity.",
     ),
   field_list: z.object({
-    first_row: z.number().int().min(1).nullable(),
-    last_row: z.number().int().min(0).nullable(),
-    count: z.number().int().min(0),
+    first_row: z.int().min(1).nullable(),
+    last_row: z.int().min(0).nullable(),
+    count: z.int().min(0),
   }),
   method_list: z.object({
-    first_row: z.number().int().min(1).nullable(),
-    last_row: z.number().int().min(0).nullable(),
-    count: z.number().int().min(0),
+    first_row: z.int().min(1).nullable(),
+    last_row: z.int().min(0).nullable(),
+    count: z.int().min(0),
   }),
 });
 
@@ -158,9 +155,9 @@ const managedExportedTypeSchema = z.object({
   row_offset: offsetSchema,
   namespace: z.string(),
   name: z.string(),
-  flags: z.number().int().min(0).max(0xffff_ffff),
+  flags: z.int().min(0).max(0xffff_ffff),
   forwarder: z.boolean(),
-  type_def_id: z.number().int().min(0).max(0xffff_ffff),
+  type_def_id: z.int().min(0).max(0xffff_ffff),
   implementation_token: managedMetadataTokenSchema.nullable(),
 });
 
@@ -170,22 +167,22 @@ const managedFieldSchema = z.object({
   declaring_type_token: managedMetadataTokenSchema.nullable(),
   declaring_type: z.string().nullable(),
   name: z.string(),
-  flags: z.number().int().min(0).max(0xffff),
+  flags: z.int().min(0).max(0xffff),
   signature: managedSignatureSchema,
 });
 
 const managedExceptionRegionSchema = z.object({
-  flags: z.number().int().min(0).max(0xffff_ffff),
-  try_offset: z.number().int().min(0),
-  try_length: z.number().int().min(0),
-  handler_offset: z.number().int().min(0),
-  handler_length: z.number().int().min(0),
+  flags: z.int().min(0).max(0xffff_ffff),
+  try_offset: z.int().min(0),
+  try_length: z.int().min(0),
+  handler_offset: z.int().min(0),
+  handler_length: z.int().min(0),
   class_token: managedMetadataTokenSchema.nullable(),
-  filter_offset: z.number().int().min(0).nullable(),
+  filter_offset: z.int().min(0).nullable(),
 });
 
 const managedInstructionAnchorSchema = z.object({
-  il_offset: z.number().int().min(0),
+  il_offset: z.int().min(0),
   opcode: z.string().min(1),
   operand_kind: z.enum([
     "none",
@@ -207,12 +204,12 @@ const managedInstructionAnchorSchema = z.object({
 const managedMethodBodySchema = z.object({
   status: z.enum(["present", "partial", "absent", "malformed"]),
   header_format: z.enum(["tiny", "fat", "none", "unknown"]),
-  rva: z.number().int().min(0).max(0xffff_ffff),
+  rva: z.int().min(0).max(0xffff_ffff),
   file_offset: offsetSchema.nullable(),
-  max_stack: z.number().int().min(0).nullable(),
+  max_stack: z.int().min(0).nullable(),
   init_locals: z.boolean().nullable(),
   local_var_sig_token: managedMetadataTokenSchema.nullable(),
-  il_size: z.number().int().min(0),
+  il_size: z.int().min(0),
   il_sha256: digestSchema
     .nullable()
     .describe(
@@ -223,10 +220,10 @@ const managedMethodBodySchema = z.object({
     .describe(
       "Member-result-v1 SHA-256 of UTF-8 JSON [opcode, operand_kind, operand] tuples for a complete decode; retains build-local tokens, omits switch targets, and excludes headers, locals, and exception regions",
     ),
-  instruction_count: z.number().int().min(0),
-  decoded_instruction_count: z.number().int().min(0),
-  truncated_instructions: z.number().int().min(0),
-  opcode_counts: z.record(z.string(), z.number().int().min(1)),
+  instruction_count: z.int().min(0),
+  decoded_instruction_count: z.int().min(0),
+  truncated_instructions: z.int().min(0),
+  opcode_counts: z.record(z.string(), z.int().min(1)),
   anchors: z.array(managedInstructionAnchorSchema),
   exception_regions: z.array(managedExceptionRegionSchema),
   issue: z.string().nullable(),
@@ -238,9 +235,9 @@ const managedMethodSchema = z.object({
   declaring_type_token: managedMetadataTokenSchema.nullable(),
   declaring_type: z.string().nullable(),
   name: z.string(),
-  rva: z.number().int().min(0).max(0xffff_ffff),
-  impl_flags: z.number().int().min(0).max(0xffff),
-  flags: z.number().int().min(0).max(0xffff),
+  rva: z.int().min(0).max(0xffff_ffff),
+  impl_flags: z.int().min(0).max(0xffff),
+  flags: z.int().min(0).max(0xffff),
   signature: managedSignatureSchema,
   body: managedMethodBodySchema,
 });
@@ -280,7 +277,7 @@ const managedModuleReferenceSchema = z.object({
 export const managedNativeImportSchema = z.object({
   token: managedMetadataTokenSchema,
   row_offset: offsetSchema,
-  mapping_flags: z.number().int().min(0).max(0xffff),
+  mapping_flags: z.int().min(0).max(0xffff),
   mapping_flags_hex: z.string().regex(/^0x[0-9a-f]{4}$/u),
   member_token: managedMetadataTokenSchema.nullable(),
   member_kind: z.enum(["method", "field", "unknown"]),
@@ -314,9 +311,9 @@ const managedNativeImplementationSchema = z.object({
   token: managedMetadataTokenSchema,
   row_offset: offsetSchema,
   name: z.string(),
-  rva: z.number().int().min(0).max(0xffff_ffff),
-  flags: z.number().int().min(0).max(0xffff),
-  impl_flags: z.number().int().min(0).max(0xffff),
+  rva: z.int().min(0).max(0xffff_ffff),
+  flags: z.int().min(0).max(0xffff),
+  impl_flags: z.int().min(0).max(0xffff),
   code_type: z.enum(["il", "native", "optil", "runtime", "unknown"]),
   managed_kind: z.enum(["managed", "unmanaged", "unknown"]),
   pinvoke_declared: z.boolean(),
@@ -387,31 +384,31 @@ const managedParseIssueSchema = z.object({
 export const managedArtifactInspectionSchema = z.object({
   artifact: managedArtifactReferenceSchema,
   pe: z.object({
-    machine: z.number().int().min(0).max(0xffff),
+    machine: z.int().min(0).max(0xffff),
     machine_hex: z.string().regex(/^0x[0-9a-f]{4}$/u),
     architecture: z.enum(["x86", "x86_64", "arm", "arm64"]),
     optional_header: z.enum(["pe32", "pe32-plus"]),
-    section_count: z.number().int().min(1).max(0xffff),
-    characteristics: z.number().int().min(0).max(0xffff),
+    section_count: z.int().min(1).max(0xffff),
+    characteristics: z.int().min(0).max(0xffff),
     cli: z
       .object({
         header_offset: offsetSchema,
-        header_size: z.number().int().min(72),
+        header_size: z.int().min(72),
         runtime_version: z.string(),
-        flags: z.number().int().min(0).max(0xffff_ffff),
+        flags: z.int().min(0).max(0xffff_ffff),
         flag_names: z.array(z.string()),
         entry_point: z.object({
           kind: z.enum(["metadata-token", "native-rva", "none"]),
           value: z.string().nullable(),
         }),
-        metadata_rva: z.number().int().min(1).max(0xffff_ffff),
-        metadata_size: z.number().int().min(1).max(0xffff_ffff),
-        resources_rva: z.number().int().min(0).max(0xffff_ffff),
-        resources_size: z.number().int().min(0).max(0xffff_ffff),
-        strong_name_rva: z.number().int().min(0).max(0xffff_ffff),
-        strong_name_size: z.number().int().min(0).max(0xffff_ffff),
-        managed_native_header_rva: z.number().int().min(0).max(0xffff_ffff),
-        managed_native_header_size: z.number().int().min(0).max(0xffff_ffff),
+        metadata_rva: z.int().min(1).max(0xffff_ffff),
+        metadata_size: z.int().min(1).max(0xffff_ffff),
+        resources_rva: z.int().min(0).max(0xffff_ffff),
+        resources_size: z.int().min(0).max(0xffff_ffff),
+        strong_name_rva: z.int().min(0).max(0xffff_ffff),
+        strong_name_size: z.int().min(0).max(0xffff_ffff),
+        managed_native_header_rva: z.int().min(0).max(0xffff_ffff),
+        managed_native_header_size: z.int().min(0).max(0xffff_ffff),
         ready_to_run_signature: z.boolean(),
       })
       .nullable(),
@@ -455,10 +452,7 @@ export const managedArtifactInspectionSchema = z.object({
     status: z.enum(["absent", "complete", "partial", "malformed"]),
     version: z.string().nullable(),
     stream_names: z.array(z.string()),
-    table_row_counts: z.record(
-      z.string(),
-      z.number().int().min(0).max(0xffff_ffff),
-    ),
+    table_row_counts: z.record(z.string(), z.int().min(0).max(0xffff_ffff)),
   }),
   module: moduleIdentitySchema.nullable(),
   assembly: assemblyIdentitySchema.nullable(),
@@ -544,17 +538,17 @@ export const managedNativeBoundaryInspectionSchema = z.object({
       strong_name_signed: z.boolean(),
       native_entry_point: z.boolean(),
       ready_to_run_signature: z.boolean(),
-      managed_native_header_rva: z.number().int().min(0).max(0xffff_ffff),
-      managed_native_header_size: z.number().int().min(0).max(0xffff_ffff),
+      managed_native_header_rva: z.int().min(0).max(0xffff_ffff),
+      managed_native_header_size: z.int().min(0).max(0xffff_ffff),
     })
     .nullable(),
   module_refs: z.array(managedModuleReferenceSchema),
   pinvoke_imports: z.array(managedNativeImportSchema),
   native_implementations: z.array(managedNativeImplementationSchema),
   summary: z.object({
-    module_ref_count: z.number().int().min(0),
-    pinvoke_import_count: z.number().int().min(0),
-    native_implementation_count: z.number().int().min(0),
+    module_ref_count: z.int().min(0),
+    pinvoke_import_count: z.int().min(0),
+    native_implementation_count: z.int().min(0),
     ready_to_run: z.boolean().nullable(),
     mixed_mode_or_native_header: z.boolean().nullable(),
   }),

src/domain/managed/managedMemberComparison.ts

@@ -164,8 +164,8 @@ export const managedMemberComparisonResultSchema = z.strictObject({
     mvid: cliMetadataGuidSchema.nullable(),
     module_name: z.string().nullable(),
     metadata_status: z.enum(["absent", "complete", "partial", "malformed"]),
-    methods_total: z.number().int().min(0),
-    fields_total: z.number().int().min(0),
+    methods_total: z.int().min(0),
+    fields_total: z.int().min(0),
   }),
   right: z.strictObject({
     evidence_id: evidenceIdSchema,
@@ -173,23 +173,23 @@ export const managedMemberComparisonResultSchema = z.strictObject({
     mvid: cliMetadataGuidSchema.nullable(),
     module_name: z.string().nullable(),
     metadata_status: z.enum(["absent", "complete", "partial", "malformed"]),
-    methods_total: z.number().int().min(0),
-    fields_total: z.number().int().min(0),
+    methods_total: z.int().min(0),
+    fields_total: z.int().min(0),
   }),
   summary: z.strictObject({
-    unchanged: z.number().int().min(0),
-    changed: z.number().int().min(0),
-    added: z.number().int().min(0),
-    removed: z.number().int().min(0),
-    unknown: z.number().int().min(0),
+    unchanged: z.int().min(0),
+    changed: z.int().min(0),
+    added: z.int().min(0),
+    removed: z.int().min(0),
+    unknown: z.int().min(0),
   }),
   matching: z.strictObject({
-    exact_il_signature: z.number().int().min(0),
-    exact_signature: z.number().int().min(0),
-    structural_method_shape: z.number().int().min(0),
-    field_signature: z.number().int().min(0),
-    ambiguous: z.number().int().min(0),
-    unmatched: z.number().int().min(0),
+    exact_il_signature: z.int().min(0),
+    exact_signature: z.int().min(0),
+    structural_method_shape: z.int().min(0),
+    field_signature: z.int().min(0),
+    ambiguous: z.int().min(0),
+    unmatched: z.int().min(0),
   }),
   methods: z.array(methodComparisonItemSchema),
   fields: z.array(fieldComparisonItemSchema),

src/domain/managed/managedNativeVerificationSchemas.ts

@@ -151,26 +151,26 @@ export const managedNativeVerificationResultSchema = z
       artifact_path: z.string().min(1),
       mvid: cliMetadataGuidSchema.nullable(),
       metadata_status: z.enum(["absent", "complete", "partial", "malformed"]),
-      pinvoke_imports_total: z.number().int().min(0),
-      native_implementations_total: z.number().int().min(0),
+      pinvoke_imports_total: z.int().min(0),
+      native_implementations_total: z.int().min(0),
       coverage_state: z.enum(["complete", "partial", "unavailable"]),
     }),
     native_observations: z.strictObject({
-      total: z.number().int().min(1),
-      accepted: z.number().int().min(0),
-      unsupported: z.number().int().min(0),
-      symbols: z.number().int().min(0),
+      total: z.int().min(1),
+      accepted: z.int().min(0),
+      unsupported: z.int().min(0),
+      symbols: z.int().min(0),
     }),
     summary: z.strictObject({
-      verified: z.number().int().min(0),
-      inferred: z.number().int().min(0),
-      unresolved: z.number().int().min(0),
-      contradicted: z.number().int().min(0),
-      native_body_unresolved: z.number().int().min(0),
+      verified: z.int().min(0),
+      inferred: z.int().min(0),
+      unresolved: z.int().min(0),
+      contradicted: z.int().min(0),
+      native_body_unresolved: z.int().min(0),
     }),
     pinvoke_imports: z.array(pinvokeVerificationSchema),
     native_implementations: z.strictObject({
-      unresolved: z.number().int().min(0),
+      unresolved: z.int().min(0),
       reason: textSchema,
     }),
     coverage: verificationCoverageSchema,

src/domain/managed/managedReconstruction.ts

@@ -34,8 +34,8 @@ const managedReconstructionMethodInputSchema = z.strictObject({
     text: textSchema,
     text_sha256: digestSchema.optional(),
     source_path: textSchema.nullable().optional(),
-    start_line: z.number().int().min(1).nullable().optional(),
-    end_line: z.number().int().min(1).nullable().optional(),
+    start_line: z.int().min(1).nullable().optional(),
+    end_line: z.int().min(1).nullable().optional(),
   }),
 });
 
@@ -57,17 +57,17 @@ const importedMethodSchema = z.strictObject({
   signature_sha256: digestSchema,
   normalized_il_sha256: digestSchema.nullable(),
   body_sha256: digestSchema.nullable(),
-  il_size: z.number().int().min(0),
+  il_size: z.int().min(0),
   reconstruction: z.strictObject({
     kind: z.enum(["decompiled-csharp", "decompiled-il", "semantic-pseudocode"]),
     language: z.enum(["csharp", "il", "pseudocode"]),
     text: textSchema,
     text_sha256: digestSchema,
-    text_length: z.number().int().min(1),
-    line_count: z.number().int().min(1),
+    text_length: z.int().min(1),
+    line_count: z.int().min(1),
     source_path: textSchema.nullable(),
-    start_line: z.number().int().min(1).nullable(),
-    end_line: z.number().int().min(1).nullable(),
+    start_line: z.int().min(1).nullable(),
+    end_line: z.int().min(1).nullable(),
   }),
   validation: z.strictObject({
     matched_static_member: z.literal(true),
@@ -85,7 +85,7 @@ export const managedReconstructionImportResultSchema = z.strictObject({
     evidence_id: evidenceIdSchema,
     artifact_sha256: digestSchema,
     artifact_path: z.string().min(1),
-    byte_length: z.number().int().min(0),
+    byte_length: z.int().min(0),
     module_name: z.string().nullable(),
     mvid: cliMetadataGuidSchema.nullable(),
     metadata_status: z.enum(["absent", "complete", "partial", "malformed"]),
@@ -94,11 +94,11 @@ export const managedReconstructionImportResultSchema = z.strictObject({
     options_sha256: digestSchema,
   }),
   summary: z.strictObject({
-    imported_methods: z.number().int().min(1),
-    decompiled_csharp_methods: z.number().int().min(0),
-    decompiled_il_methods: z.number().int().min(0),
-    pseudocode_methods: z.number().int().min(0),
-    total_text_bytes: z.number().int().min(1),
+    imported_methods: z.int().min(1),
+    decompiled_csharp_methods: z.int().min(0),
+    decompiled_il_methods: z.int().min(0),
+    pseudocode_methods: z.int().min(0),
+    total_text_bytes: z.int().min(1),
   }),
   methods: z.array(importedMethodSchema).min(1),
   notes: z.array(textSchema),

src/domain/native/binaryLayout.ts

@@ -6,8 +6,8 @@ import { absoluteLocalPathStringSchema } from "../localPath.js";
 import { canonicalBase64Schema } from "../stringPatterns.js";
 
 const unsignedHex = z.string().regex(/^0x(?:0|[1-9a-f][0-9a-f]{0,15})$/);
-const index = z.number().int().nonnegative();
-const scalar = z.union([z.string(), z.number().int()]);
+const index = z.int().nonnegative();
+const scalar = z.union([z.string(), z.int()]);
 const range = z.strictObject({ offset: unsignedHex, bytes: unsignedHex });
 const canonicalBase64 = canonicalBase64Schema;
 const name = z.strictObject({

src/domain/native/bytePattern.ts

@@ -115,7 +115,7 @@ const coverageBlock = z
     segment: z.string(),
     start: z.string(),
     end: z.string(),
-    bytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    bytes: z.int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   })
   .superRefine((value, context) => {
     const start = addressCoordinate(value.start);
@@ -143,7 +143,6 @@ export const byteSearchResultSchema = z
           address: z.string(),
           segment: z.string(),
           file_offset: z
-            .number()
             .int()
             .nonnegative()
             .max(Number.MAX_SAFE_INTEGER)
@@ -156,7 +155,7 @@ export const byteSearchResultSchema = z
       .max(1000),
     searched: z.strictObject({
       blocks: z.array(coverageBlock),
-      bytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+      bytes: z.int().nonnegative().max(Number.MAX_SAFE_INTEGER),
       skipped_uninitialized: z.array(coverageBlock),
       skipped_not_loaded: z.array(coverageBlock),
     }),

src/domain/native/nativeApiBoundary.ts

@@ -17,10 +17,10 @@ const inferenceEvidenceSchema = z
   .strict();
 
 const inferredBoundaryTypeFacts = {
-  ordinal: z.number().int().min(0).nullable(),
+  ordinal: z.int().min(0).nullable(),
   name: z.string().min(1).nullable(),
   data_type: z.string().min(1),
-  size_bytes: z.number().int().min(0).nullable(),
+  size_bytes: z.int().min(0).nullable(),
   storage: z.string().min(1).nullable(),
   confidence: inferenceConfidenceSchema,
   evidence: z.array(inferenceEvidenceSchema).min(1),
@@ -43,7 +43,7 @@ const inferredReturnTypeSchema = z.strictObject({
 const inferredParameterTypeSchema = z.strictObject({
   ...inferredBoundaryTypeFacts,
   role: z.literal("parameter"),
-  ordinal: z.number().int().min(0),
+  ordinal: z.int().min(0),
 });
 
 const jumpTableDataSourceSchema = z
@@ -55,8 +55,8 @@ const jumpTableDataSourceSchema = z
       "ghidra-aarch64-byte-table",
       "ghidra-aarch64-halfword-table",
     ]),
-    entry_size_bytes: z.number().int().min(1).nullable(),
-    entry_count: z.number().int().min(0).nullable(),
+    entry_size_bytes: z.int().min(1).nullable(),
+    entry_count: z.int().min(0).nullable(),
     confidence: inferenceConfidenceSchema,
     evidence: z.array(inferenceEvidenceSchema).min(1),
   })
@@ -64,7 +64,7 @@ const jumpTableDataSourceSchema = z
 
 const jumpTableMappingSchema = z
   .object({
-    case_value: z.number().int().nullable(),
+    case_value: z.int().nullable(),
     target_address: z.string().min(1),
     confidence: inferenceConfidenceSchema,
     evidence: z.array(inferenceEvidenceSchema).min(1),