Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

perf(analysis-view): reuse validated immutable parents

Ysopwnable8f7d12e30d63
diff --git a/experiments/analysis-efficiency/README.md b/experiments/analysis-efficiency/README.md
index 227ed379c..75da2d5e9 100644
--- a/experiments/analysis-efficiency/README.md
+++ b/experiments/analysis-efficiency/README.md
@@ -1,5 +1,10 @@
# Analysis efficiency measurements
+For immutable imported native/JavaScript parents, see the
+[validation-reuse checkpoint](immutable-parent-validation.md). It measures the
+owning format change with the existing retained-query driver, including first
+view costs, small cases, unchanged token estimates, and noisy whole-task results.
+
For authentic old Evidence and mixed investigations, see the
[retained-query checkpoint](retained-investigation-workflows.md).
`retained-investigation.mjs` compares existing complete delivery with selected
diff --git a/experiments/analysis-efficiency/immutable-parent-validation.json b/experiments/analysis-efficiency/immutable-parent-validation.json
new file mode 100644
index 000000000..b54409015
--- /dev/null
+++ b/experiments/analysis-efficiency/immutable-parent-validation.json
@@ -0,0 +1,654 @@
+{
+ "issue": "https://github.com/morluto/rea/issues/4810",
+ "baseline": "2c4338db1fdb7773e05376301c558cff2a0b4b80",
+ "candidate": "3930a640fb8387cbd3079eee13fb90f82d1881dc",
+ "units": {
+ "latency": "milliseconds",
+ "elapsed_cpu": "seconds",
+ "memory": "kernel cgroup memory.peak bytes, including charged file cache and descendants"
+ },
+ "scope": "Three alternating before/after pairs per authentic retained native/JavaScript/small workflow; fresh stdio servers, three traversals of three two-row pages; catalog/import/oracles/export/close included in whole cost. OS caches uncontrolled. No actual model trial.",
+ "resource_bounds": {
+ "cpu_count": 1,
+ "hard_memory_bytes": 8589934592,
+ "early_stop_bytes": 7516192768,
+ "swap_bytes": 0,
+ "tasks_max": 192,
+ "host_start_available_bytes_min": 17179869184,
+ "host_stop_available_bytes_min": 8589934592,
+ "observer_sha256": "6f089e645459eba80c5d73e39c21606c78173a44daf49fabc3b88c4631ce51c6",
+ "guard_sha256s": [
+ "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992",
+ "d2047721e50dd244900eb514d07025386e60908f77bb546bee5684baa1da2f19"
+ ],
+ "guard_observability_note": "The newer private guard only records existing host-available-memory readings and its own cgroup path. Resource thresholds, CPU affinity, observer and stop/cleanup logic are unchanged."
+ },
+ "resource_accounting": "Final complete corpus tasks exit0/cleanup verified/oom0 at payload exit while observer remains alive. Resource-stopped and earlier failed attempts are recorded separately; terminal whole-scope counters are unavailable. Weak cache metadata/private heap not measured independently.",
+ "catalog": {
+ "tools": 207,
+ "bytes": 3158368,
+ "sha256": "1d6c9a679b7c935318f5ea59d5362ef0a06945b3f4a4f210c86997ec15ba4f4c",
+ "equal_across_all_18_runs": true
+ },
+ "facts": {
+ "native": {
+ "answer_sha256": "4e28c2c2a25620576d27abe846a05835ec49386b889779e33410c31971523b54",
+ "calls": 25,
+ "query_structured_content_equal": true,
+ "original_records_preserved": true,
+ "closed_session_cleared": true
+ },
+ "javascript": {
+ "answer_sha256": "0fe3ad249eb1a7233a4966a56652c173667c48fdaf395b6c08fc6901ef3b46f7",
+ "calls": 28,
+ "query_structured_content_equal": true,
+ "original_records_preserved": true,
+ "closed_session_cleared": true
+ },
+ "small": {
+ "answer_sha256": "9ca5874ce7bb610e39632157304fe4f52b09401d5fbd97ec981ad0588b8da485",
+ "calls": 19,
+ "query_structured_content_equal": true,
+ "original_records_preserved": true,
+ "closed_session_cleared": true
+ }
+ },
+ "runs": [
+ {
+ "name": "topology-paired-after-javascript-1",
+ "first_page_ms": 2720.542831999999,
+ "eight_later_pages_ms": 82.69408900000417,
+ "elapsed_seconds": 20.713,
+ "family_cpu_seconds": 20.50093,
+ "family_peak_bytes": 1311358976,
+ "import_ms": 10970.411619,
+ "catalog_ms": 1194.7045099999996,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-after-javascript-2",
+ "first_page_ms": 1978.732818999999,
+ "eight_later_pages_ms": 84.12934999999197,
+ "elapsed_seconds": 20.011,
+ "family_cpu_seconds": 19.733879,
+ "family_peak_bytes": 1349349376,
+ "import_ms": 10382.461203,
+ "catalog_ms": 1436.8567430000003,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-after-javascript-4",
+ "first_page_ms": 1864.8931889999985,
+ "eight_later_pages_ms": 75.18833300000188,
+ "elapsed_seconds": 23.023,
+ "family_cpu_seconds": 22.22643,
+ "family_peak_bytes": 1410211840,
+ "import_ms": 10857.059245,
+ "catalog_ms": 2247.621502,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-after-native-1",
+ "first_page_ms": 216.87685000000056,
+ "eight_later_pages_ms": 85.03580100000181,
+ "elapsed_seconds": 17.253,
+ "family_cpu_seconds": 17.002728,
+ "family_peak_bytes": 1003585536,
+ "import_ms": 10361.605091,
+ "catalog_ms": 1289.5255869999992,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-after-native-2",
+ "first_page_ms": 209.0475239999996,
+ "eight_later_pages_ms": 89.01302899999973,
+ "elapsed_seconds": 14.383,
+ "family_cpu_seconds": 14.091764,
+ "family_peak_bytes": 1031806976,
+ "import_ms": 7696.751557,
+ "catalog_ms": 1175.233292,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-after-native-3",
+ "first_page_ms": 203.10824999999932,
+ "eight_later_pages_ms": 65.1013469999998,
+ "elapsed_seconds": 14.061,
+ "family_cpu_seconds": 13.773228,
+ "family_peak_bytes": 1098002432,
+ "import_ms": 7967.397724,
+ "catalog_ms": 1246.0458209999997,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-before-javascript-1",
+ "first_page_ms": 1681.2564180000008,
+ "eight_later_pages_ms": 10378.131188999992,
+ "elapsed_seconds": 31.213,
+ "family_cpu_seconds": 30.872607,
+ "family_peak_bytes": 1618685952,
+ "import_ms": 11051.493961999999,
+ "catalog_ms": 1508.7439510000004,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-before-javascript-2",
+ "first_page_ms": 2441.075147000003,
+ "eight_later_pages_ms": 15534.410540000004,
+ "elapsed_seconds": 40.856,
+ "family_cpu_seconds": 40.485251,
+ "family_peak_bytes": 1364238336,
+ "import_ms": 15032.366213,
+ "catalog_ms": 1319.6895839999997,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-before-javascript-4",
+ "first_page_ms": 2479.6895360000017,
+ "eight_later_pages_ms": 16864.908822999998,
+ "elapsed_seconds": 39.629,
+ "family_cpu_seconds": 39.267656,
+ "family_peak_bytes": 1403023360,
+ "import_ms": 12437.073842999998,
+ "catalog_ms": 1212.8024130000003,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-before-native-1",
+ "first_page_ms": 170.1303939999998,
+ "eight_later_pages_ms": 469.8933869999928,
+ "elapsed_seconds": 19.996,
+ "family_cpu_seconds": 19.55106,
+ "family_peak_bytes": 1063051264,
+ "import_ms": 11242.171146,
+ "catalog_ms": 1922.7818150000003,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-before-native-2",
+ "first_page_ms": 183.56196199999977,
+ "eight_later_pages_ms": 393.4744759999994,
+ "elapsed_seconds": 15.26,
+ "family_cpu_seconds": 15.008304,
+ "family_peak_bytes": 1058492416,
+ "import_ms": 8713.099498,
+ "catalog_ms": 1272.265849,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-paired-before-native-3",
+ "first_page_ms": 244.26586400000087,
+ "eight_later_pages_ms": 517.9172599999911,
+ "elapsed_seconds": 19.083,
+ "family_cpu_seconds": 18.752553,
+ "family_peak_bytes": 1109987328,
+ "import_ms": 9948.476274999999,
+ "catalog_ms": 1879.787958,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-after-small-1",
+ "first_page_ms": 226.6032009999999,
+ "eight_later_pages_ms": 57.69190299999718,
+ "elapsed_seconds": 12.312,
+ "family_cpu_seconds": 12.043895,
+ "family_peak_bytes": 1056452608,
+ "import_ms": 6572.925846000001,
+ "catalog_ms": 1173.0129960000004,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-after-small-2",
+ "first_page_ms": 556.2178050000002,
+ "eight_later_pages_ms": 96.23635600000307,
+ "elapsed_seconds": 16.246,
+ "family_cpu_seconds": 16.068419,
+ "family_peak_bytes": 1002749952,
+ "import_ms": 9666.640497,
+ "catalog_ms": 1821.1315130000003,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-after-small-4",
+ "first_page_ms": 111.79372199999852,
+ "eight_later_pages_ms": 62.58284999999887,
+ "elapsed_seconds": 11.901,
+ "family_cpu_seconds": 11.707784,
+ "family_peak_bytes": 976646144,
+ "import_ms": 6473.91882,
+ "catalog_ms": 1203.5203539999998,
+ "guard_sha256": "d2047721e50dd244900eb514d07025386e60908f77bb546bee5684baa1da2f19"
+ },
+ {
+ "name": "topology-before-small-1",
+ "first_page_ms": 242.57812199999898,
+ "eight_later_pages_ms": 299.467095,
+ "elapsed_seconds": 17.585,
+ "family_cpu_seconds": 17.312434,
+ "family_peak_bytes": 1066864640,
+ "import_ms": 9102.074585,
+ "catalog_ms": 1829.971928,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-before-small-2",
+ "first_page_ms": 133.3346359999996,
+ "eight_later_pages_ms": 122.92684500000178,
+ "elapsed_seconds": 14.302,
+ "family_cpu_seconds": 13.936122,
+ "family_peak_bytes": 1062400000,
+ "import_ms": 7254.973107,
+ "catalog_ms": 1170.888121,
+ "guard_sha256": "760d541c60f4c0538f9c015964196e3be7bba12316f6085903244354e11aa992"
+ },
+ {
+ "name": "topology-before-small-4",
+ "first_page_ms": 100.81227200000103,
+ "eight_later_pages_ms": 76.37957900000038,
+ "elapsed_seconds": 12.0,
+ "family_cpu_seconds": 11.765305,
+ "family_peak_bytes": 983314432,
+ "import_ms": 6614.461618999999,
+ "catalog_ms": 1138.6469730000003,
+ "guard_sha256": "d2047721e50dd244900eb514d07025386e60908f77bb546bee5684baa1da2f19"
+ }
+ ],
+ "token_estimates": {
+ "tokenizer": "tiktoken",
+ "version": "0.12.0",
+ "encoding": "cl100k_base",
+ "kind": "offline raw transport serialization estimate; one complete catalog plus each call name/arguments/reply exactly once; excludes initialization/framing, prompts, client rendering/discovery/replay, continuations and actual model usage; not an agent-token measurement",
+ "runs": [
+ {
+ "run": "topology-paired-before-native-1",
+ "catalog_tokens_estimated": 805215,
+ "named_call_arguments_tokens_estimated": 1200,
+ "reply_tokens_estimated": 43321,
+ "total_tokens_estimated": 849736,
+ "calls": 25
+ },
+ {
+ "run": "topology-paired-after-native-1",
+ "catalog_tokens_estimated": 805215,
+ "named_call_arguments_tokens_estimated": 1200,
+ "reply_tokens_estimated": 43321,
+ "total_tokens_estimated": 849736,
+ "calls": 25
+ },
+ {
+ "run": "topology-paired-before-javascript-1",
+ "catalog_tokens_estimated": 805215,
+ "named_call_arguments_tokens_estimated": 1354,
+ "reply_tokens_estimated": 49815,
+ "total_tokens_estimated": 856384,
+ "calls": 28
+ },
+ {
+ "run": "topology-paired-after-javascript-1",
+ "catalog_tokens_estimated": 805215,
+ "named_call_arguments_tokens_estimated": 1354,
+ "reply_tokens_estimated": 49815,
+ "total_tokens_estimated": 856384,
+ "calls": 28
+ },
+ {
+ "run": "topology-before-small-1",
+ "catalog_tokens_estimated": 805215,
+ "named_call_arguments_tokens_estimated": 1118,
+ "reply_tokens_estimated": 33970,
+ "total_tokens_estimated": 840303,
+ "calls": 19
+ },
+ {
+ "run": "topology-after-small-1",
+ "catalog_tokens_estimated": 805215,
+ "named_call_arguments_tokens_estimated": 1118,
+ "reply_tokens_estimated": 33970,
+ "total_tokens_estimated": 840303,
+ "calls": 19
+ }
+ ]
+ },
+ "mixed_verification": [
+ {
+ "scenario": "native",
+ "heads_checked": 64,
+ "pages": 32,
+ "revised_unknown_id": "unk_057c8f2dbf30ec98851a66ee054366bc6e2e168874581e6f99cb80673d0ff9b8",
+ "revision_checked": 2,
+ "stale_update_rejected": true,
+ "tampered_import_rejected_atomically": true,
+ "unknowns_after_close": 0,
+ "old_reference_refused": true
+ },
+ {
+ "scenario": "javascript",
+ "heads_checked": 64,
+ "pages": 32,
+ "revised_unknown_id": "unk_057c8f2dbf30ec98851a66ee054366bc6e2e168874581e6f99cb80673d0ff9b8",
+ "revision_checked": 2,
+ "stale_update_rejected": true,
+ "tampered_import_rejected_atomically": true,
+ "unknowns_after_close": 0,
+ "old_reference_refused": true
+ }
+ ],
+ "cli_parity": [
+ {
+ "scenario": "native",
+ "exact_json_equal": true,
+ "exact_bytes_equal": true,
+ "bytes": 7316,
+ "sha256_before": "eada9068db3b499da332b2c5226fdd3a48909ebcaa290fd72166325e2f664fca",
+ "sha256_after": "eada9068db3b499da332b2c5226fdd3a48909ebcaa290fd72166325e2f664fca",
+ "evidence_id": "ev_521a58e81427bb4b2c01b6a291bdfd7698068ee0eba371696daa9cc5ab32f3f0",
+ "evidence_links": [
+ "ev_14b4582084e425b597bea6246f0df94ab4856ac3ab9502c96551147210ca9c8b"
+ ]
+ },
+ {
+ "scenario": "javascript",
+ "exact_json_equal": true,
+ "exact_bytes_equal": true,
+ "bytes": 8876,
+ "sha256_before": "1dc023e5ece8f9c8cea736cb0db4d4f60c9418f1573e1e46ff0ac55a4273cb5a",
+ "sha256_after": "1dc023e5ece8f9c8cea736cb0db4d4f60c9418f1573e1e46ff0ac55a4273cb5a",
+ "evidence_id": "ev_97cac46d5139f6c48c3142798087814dcf36a37a9c99f7253668576bd3ae282a",
+ "evidence_links": [
+ "ev_dd2ffe5ab2faa6e07e422886f64a87f99e35a0a1dce1acb5351b7a81cb2c9a11"
+ ]
+ },
+ {
+ "scenario": "small",
+ "exact_json_equal": true,
+ "exact_bytes_equal": true,
+ "bytes": 7181,
+ "sha256_before": "00dd070690e7b113e0cad73f9f7bcda6f42c515f8fdcc5173e8815bd3748b084",
+ "sha256_after": "00dd070690e7b113e0cad73f9f7bcda6f42c515f8fdcc5173e8815bd3748b084",
+ "evidence_id": "ev_3dcbcc5b2002f1e6caf7df005e3fcfd06a3afe14ccd72fff924c8e76d8498914",
+ "evidence_links": [
+ "ev_775d6cc6d0de96402b6e57a4258a0b78c337cfb1b7760aa22c39c3ee450c7dff"
+ ]
+ }
+ ],
+ "stopped_source_validation": {
+ "reason": "Started during initial before-javascript-3; stopped only the new owned validation scope, then retried serially. Baseline repetition3 retained but excluded from uncontended exploratory comparisons; all final cohort runs retained.",
+ "status": "incomplete, shell reported exit241; no payload-completion receipt",
+ "elapsed_seconds": 17.272,
+ "family_cpu_seconds_last_observed": 12.204013,
+ "peak_cgroup_bytes_sampled": 589766656,
+ "final_scope_counters": null
+ },
+ "exploratory_costs": {
+ "completed_tasks": 21,
+ "elapsed_seconds_total": 649.262,
+ "family_cpu_seconds_total": 599.762599,
+ "family_peak_bytes_max": 1741795328,
+ "comparison_status": "Earlier candidate and exploratory inputs; excluded from final comparison, raw individual reports retained in private audit cache.",
+ "contended_baseline_task": {
+ "name": "before-javascript-3",
+ "revision": "2c4338db1fdb7773e05376301c558cff2a0b4b80",
+ "status": "passed",
+ "elapsed_seconds": 100.722,
+ "family_cpu_seconds": 82.656181,
+ "family_peak_bytes": 1290514432,
+ "excluded_from_final_comparison": true
+ }
+ },
+ "runtime_entry_sha256": {
+ "before": "1586cea18f4d4702c949502cfc143a7dfd2c28414779e190ce8a42fedf90bd74",
+ "after": "e05c70bed21c680445a5c6e314a16cce6f22f3909f93388bf602338062e63d1a"
+ },
+ "inputs": {
+ "native": {
+ "bundle_sha256": "180c6fe6d3706d9272c8bb33503c2dca6f145d5061e102e3457dd5f2d754b5c9",
+ "bundle_bytes": 1745224,
+ "source_evidence_id": "ev_14b4582084e425b597bea6246f0df94ab4856ac3ab9502c96551147210ca9c8b"
+ },
+ "javascript": {
+ "bundle_sha256": "747ff602093a24d4876e3eb47da3f7ef68716a10ac7c09938f43c3be5c33e31d",
+ "bundle_bytes": 21058430,
+ "source_evidence_id": "ev_dd2ffe5ab2faa6e07e422886f64a87f99e35a0a1dce1acb5351b7a81cb2c9a11"
+ },
+ "small": {
+ "bundle_sha256": "44ca561c2455706897d2ae8f51f45693e7276badd5e8454ec31d8c1b0cfb77eb",
+ "bundle_bytes": 73051,
+ "source_evidence_id": "ev_775d6cc6d0de96402b6e57a4258a0b78c337cfb1b7760aa22c39c3ee450c7dff"
+ }
+ },
+ "validation": {
+ "source": {
+ "executed": "130 source tests across5files; check:fast; build:cached",
+ "elapsed_seconds": 334.264,
+ "family_cpu_seconds": 326.441674,
+ "family_peak_bytes": 4487696384,
+ "payload_exit_code": 0,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ "compiled_boundary": {
+ "executed": "36 CLI/MCP tests across4files",
+ "elapsed_seconds": 93.343,
+ "family_cpu_seconds": 91.926502,
+ "family_peak_bytes": 2190270464,
+ "payload_exit_code": 0,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ "full_checks": {
+ "source": "3930a640fb8387cbd3079eee13fb90f82d1881dc",
+ "executed": "npm run check; npm run docs:check (five README consistency tests)",
+ "elapsed_seconds": 45.552,
+ "family_cpu_seconds": 43.309041,
+ "family_peak_bytes": 1127768064,
+ "payload_exit_code": 0,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ "integration_current": {
+ "source": "3930a640fb8387cbd3079eee13fb90f82d1881dc",
+ "executed": "npm run test:focused -- three latest-main integration files; default test deadlines; 27 passed",
+ "elapsed_seconds": 62.437,
+ "family_cpu_seconds": 61.506209,
+ "family_peak_bytes": 1846538240,
+ "payload_exit_code": 0,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ }
+ },
+ "comparison_probe": {
+ "scope": "Candidate-only internal JSON-owner regression, not baseline public-provider reproduction. Reflect.ownKeys instrumentation aborts at10000 inspections rather than consuming exponential CPU.",
+ "objects_per_graph": 27,
+ "before_candidate": "e30a94a4de6a3c4ec7c577c1551d2b448d82081e",
+ "before_inspections": 10001,
+ "before_status": "probe inspection budget exhausted",
+ "after_candidate": "646312dad75e2cb2becb0dd4139b99a1c04d6bcc",
+ "after_inspections": 54,
+ "after_borrowed": true
+ },
+ "main_integration": {
+ "main_commit": "bb212ffecb47e129cc569b9867b2b6e7c9b65685",
+ "merge_commit": "71e0b2739a9cf9903e1cfa63dc5a5b576040fea7",
+ "production_files_unchanged_from_measured_candidate": true,
+ "scope": "Historical integration at71e0b2739 with production source646312dad; all attempts retained. Current source-specific checks are listed separately.",
+ "attempts": [
+ {
+ "case": "initial_feature",
+ "entrypoint": "npm run test:focused",
+ "test_timeout_override_ms": null,
+ "tests_passed": 26,
+ "tests_failed": 1,
+ "tests_skipped": 0,
+ "payload_exit_code": 1,
+ "elapsed_seconds": 139.805,
+ "family_cpu_seconds": 125.252141,
+ "family_peak_bytes": 1994223616,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ {
+ "case": "isolated_main",
+ "entrypoint": "vitest run; one named test",
+ "test_timeout_override_ms": null,
+ "tests_passed": 1,
+ "tests_failed": 0,
+ "tests_skipped": 10,
+ "payload_exit_code": 0,
+ "elapsed_seconds": 25.96,
+ "family_cpu_seconds": 25.502365,
+ "family_peak_bytes": 1221394432,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ {
+ "case": "direct_main",
+ "entrypoint": "vitest run; three files",
+ "test_timeout_override_ms": null,
+ "tests_passed": 27,
+ "tests_failed": 0,
+ "tests_skipped": 0,
+ "payload_exit_code": 0,
+ "elapsed_seconds": 68.868,
+ "family_cpu_seconds": 68.020337,
+ "family_peak_bytes": 1605603328,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ {
+ "case": "extended_feature",
+ "entrypoint": "vitest run; three files",
+ "test_timeout_override_ms": 120000,
+ "tests_passed": 27,
+ "tests_failed": 0,
+ "tests_skipped": 0,
+ "payload_exit_code": 0,
+ "elapsed_seconds": 75.866,
+ "family_cpu_seconds": 75.193788,
+ "family_peak_bytes": 1937674240,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ {
+ "case": "exact_main",
+ "entrypoint": "npm run test:focused",
+ "test_timeout_override_ms": null,
+ "tests_passed": 27,
+ "tests_failed": 0,
+ "tests_skipped": 0,
+ "payload_exit_code": 0,
+ "elapsed_seconds": 66.443,
+ "family_cpu_seconds": 65.304325,
+ "family_peak_bytes": 2055409664,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ },
+ {
+ "case": "exact_feature",
+ "entrypoint": "npm run test:focused",
+ "test_timeout_override_ms": null,
+ "tests_passed": 27,
+ "tests_failed": 0,
+ "tests_skipped": 0,
+ "payload_exit_code": 0,
+ "elapsed_seconds": 66.878,
+ "family_cpu_seconds": 66.012242,
+ "family_peak_bytes": 1907380224,
+ "payload_cleanup_verified": true,
+ "oom_events_at_payload_exit": 0
+ }
+ ],
+ "measured_production_commit": "646312dad75e2cb2becb0dd4139b99a1c04d6bcc"
+ },
+ "small_cache_diagnostic": {
+ "scope": "Additional real public MCP run with return-preserving WeakSet method instrumentation. Timings excluded from before/after comparison. Owner identified from captured add stack; raw trace retained privately.",
+ "format_owner": "safeParseOwnedBinaryLayout",
+ "source_objects": 1,
+ "successful_admissions": 1,
+ "misses": 1,
+ "hits": 8,
+ "queries": 9,
+ "original_records_preserved": true,
+ "closed_session_cleared": true,
+ "small_workflow_latency_regression_retained": true,
+ "measured_production_commit": "646312dad75e2cb2becb0dd4139b99a1c04d6bcc"
+ },
+ "previous_checkpoints": [
+ {
+ "production_commit": "e30a94a4de6a3c4ec7c577c1551d2b448d82081e",
+ "report_commit": "3f271efdef8d71020bdcfd7b2d3d9817bf0a6ad8",
+ "report_url": "https://github.com/morluto/rea/blob/3f271efdef8d71020bdcfd7b2d3d9817bf0a6ad8/experiments/analysis-efficiency/immutable-parent-validation.json",
+ "completed_paired_tasks": 18,
+ "elapsed_seconds_total": 498.234,
+ "family_cpu_seconds_total": 477.513448,
+ "family_peak_bytes_max": 1519980544,
+ "scope": "Historical candidate before shared-node comparison memoization; every result retained, including slow npm repetition3. Not the final comparison."
+ },
+ {
+ "production_commit": "646312dad75e2cb2becb0dd4139b99a1c04d6bcc",
+ "report_commit": "fc55be1e05555c6b295209ef5f354617f663b8f8",
+ "report_url": "https://github.com/morluto/rea/blob/fc55be1e05555c6b295209ef5f354617f663b8f8/experiments/analysis-efficiency/immutable-parent-validation.json",
+ "completed_paired_tasks": 18,
+ "elapsed_seconds_total": 483.511,
+ "family_cpu_seconds_total": 458.990461,
+ "family_peak_bytes_max": 1598119936,
+ "scope": "Historical candidate before shared-node comparison memoization; every result retained, including slow npm repetition3. Not the final comparison."
+ }
+ ],
+ "review_normalization_fix": {
+ "comment": "https://github.com/morluto/rea/pull/4962#discussion_r4305886491",
+ "before_source": "646312dad75e2cb2becb0dd4139b99a1c04d6bcc",
+ "before_pr_head": "fc55be1e05555c6b295209ef5f354617f663b8f8",
+ "expected_failing_regressions": 4,
+ "after_source": "3930a640fb8387cbd3079eee13fb90f82d1881dc",
+ "source_tests_passed": 130,
+ "structural_fix": "Two-way node identity mapping visits preserved descendants; already-owned JavaScript graph path keeps parsed metadata and avoids whole-graph comparison. Only the expensive imported fallback admits the full-result cache.",
+ "red_probe_cost": {
+ "elapsed_seconds": 5.332,
+ "family_cpu_seconds": 4.412336,
+ "family_peak_bytes": 438231040,
+ "payload_exit_code": 1,
+ "payload_cleanup_verified": true,
+ "expected_failures": 4
+ },
+ "current_dag_probe": {
+ "source": "3930a640fb8387cbd3079eee13fb90f82d1881dc",
+ "objects_per_graph": 27,
+ "inspections": 54,
+ "borrowed": true
+ }
+ },
+ "resource_stops": [
+ {
+ "task": "topology-paired-after-javascript-3",
+ "status": "incomplete",
+ "reason": "host_available_memory_early_stop",
+ "elapsed_seconds": 15.048,
+ "family_cpu_seconds_last_observed": 14.048702,
+ "peak_cgroup_bytes_sampled": 947695616,
+ "payload_completion_counters": null,
+ "owned_scope_after_stop": "inactive/dead",
+ "replacement": "fresh JavaScript pair4, after then before; final pairs1,2,4"
+ },
+ {
+ "task": "topology-before-small-3",
+ "status": "incomplete",
+ "reason": "host_available_memory_early_stop",
+ "elapsed_seconds": 11.83,
+ "family_cpu_seconds_last_observed": 11.535779,
+ "peak_cgroup_bytes_sampled": 947818496,
+ "payload_completion_counters": null,
+ "replacement": "fresh small pair4 after memory recovered; final small pairs1,2,4"
+ }
+ ],
+ "unpaired_completed_attempts": [
+ {
+ "task": "topology-paired-before-javascript-3",
+ "status": "passed",
+ "original_records_preserved": true,
+ "elapsed_seconds": 38.862,
+ "family_cpu_seconds": 38.570479,
+ "family_peak_bytes": 1390338048,
+ "reason_not_in_paired_summary": "Its paired candidate was resource-stopped; kept separately, with both sides rerun as pair4."
+ }
+ ]
+}
diff --git a/experiments/analysis-efficiency/immutable-parent-validation.md b/experiments/analysis-efficiency/immutable-parent-validation.md
new file mode 100644
index 000000000..b4bc0bc26
--- /dev/null
+++ b/experiments/analysis-efficiency/immutable-parent-validation.md
@@ -0,0 +1,249 @@
+# Reuse successful immutable parent validation
+
+This checkpoint addresses [#4810](https://github.com/morluto/rea/issues/4810),
+found in the [retained-investigation audit](retained-investigation-workflows.md).
+It changes the shared format interpretation used by CLI and MCP views, without
+adding a tool, changing a schema, projecting away source data, or rerunning a
+provider.
+
+## Question, ownership, and compatibility
+
+The task resumes authentic exported Evidence in a fresh production stdio MCP
+server, discovers its source, reads six original symbols or modules in two-row
+pages, repeats that traversal three times, queries the existing Unknowns,
+exports the investigation, and closes it. The original source records must
+survive the round trip exactly. Pages are compared to original retained facts.
+Independent ELF byte decoding checks symbol names, values, and ranges; JavaScript
+checks cover selected source bytes and the `lib/cli.js` module identity, rather
+than independently proving the entire application inventory or semantic graph.
+
+Imported JavaScript graphs lack the producer's realm-private format proofs.
+Previously each view repeated full schema, graph/hash, and cross-graph binding
+validation. Native layout views likewise parsed the entire layout for every
+page. An immutable Evidence root alone was insufficient: its selected normalized
+result did not carry the JSON owner's private sealing proof.
+
+The JSON owner now transfers that proof to a selected own member without another
+walk or per-node registration. Native layouts and imported JavaScript results
+record a **successful full
+validation of the exact immutable source** in their owning WeakSets. Already
+owned JavaScript graphs keep the existing metadata normalization and binding
+checks, returning parsed metadata with their original graph references. That
+path avoids rewalking a large owned graph just to borrow its wrapper. There is
+no second
+retained parsed graph, strong cache, cross-process cache, or live-state cache.
+The schema implementation is fixed for the process; a different source object
+must validate independently. Weak entries do not keep Evidence alive, and session
+lookup continues to gate access after close.
+
+Cache admission follows full validation and requires that parsing preserved the
+source representation. A shared iterative JSON comparison checks own data keys,
+scalar values, prototypes, and enumerability without calling accessors. Object
+member order is immaterial; array order remains exact. Two-way identity maps
+visit preserved descendants once and reject source-node splits or merges. Both
+comparison maps are temporary and discarded on return. Parser defaults,
+hidden-field removal, or other normalization retain the parser's
+result and do not cache the source. Writable/configurable descriptor differences
+are immaterial: the source is sealed while the temporary parse is mutable.
+The JSON sealing boundary rejects proxies before reflection, so arbitrary
+mutable proxy behavior cannot acquire an immutable proof. Mutable, merely
+Object.freeze'd, failed, and abandoned inputs do not qualify for successful
+format reuse.
+
+No Evidence identity, source linkage, coverage, unknown, omission, error, or
+caller-selected page changes are intended. Complete source Evidence remains
+accessible through the existing contracts. The first imported view still pays for full
+validation and the representation comparison; a one-off CLI invocation cannot
+benefit from a cache in a previous process.
+
+## Inputs and measurement scope
+
+Baseline: `2c4338db1fdb7773e05376301c558cff2a0b4b80` (REA 6.6.0).
+Node 24.18.0, npm 11.16.0, Linux x86-64 (AMD EPYC 7B12, kernel 6.1.0-53-cloud).
+The ELF producer reports pwntools 4.15.0, pyelftools 0.33, and Unicorn 2.1.2.
+The baseline's built runtime was preserved
+before production changes. Candidate and baseline use the same locked packages.
+
+- SQLite `/usr/lib/x86_64-linux-gnu/libsqlite3.so.0.8.6`: SHA-256
+ `2e6eef9a727f081f0d453b4e5e6cbd8b9ef8b6f86cbf7681cbad444d3b0b55c8`;
+ 26 sections, 1,479 symbols, 2,963 relocations. Original history: 1,745,224 bytes.
+- Shipped npm 11.16.0: inventory digest
+ `f8e576a7d162542c616168b25a95a5f62b9accf29467cc37e149905ad4b8e603`;
+ five explicitly selected paths (`package.json`, `bin/npm-cli.js`, `lib/cli.js`,
+ `lib/cli/entry.js`, `lib/commands/install.js`), 2,822 application nodes,
+ 1,796 semantic nodes, 13,682 semantic unknowns. The 1,416 unselected files stay
+ unknown. Original history: 21,058,430 bytes.
+- Small case `/usr/bin/true`: SHA-256
+ `c79bf44242829108e323378531f4ac839513ca1fba45efd6583643526e1e9fd2`;
+ 31 sections, 53 symbols, 66 relocations. Produced through the real production
+ `inspect_binary_layout` MCP operation. An independent raw ELF reader checked
+ every symbol name, value, and source range plus section/relocation counts.
+
+The two larger histories were produced and independently checked in the linked
+previous audit. They are historical Evidence, not a claim of fresh provider
+analysis during a resumed view. All tasks here are static; no target executable
+is run.
+
+Each completed comparison includes startup, the complete 207-tool catalog,
+import, queries, oracle checks, export, close, receipt writing, and SDK cleanup.
+RPC timings exclude subsequent client-side oracle/receipt work. Fresh servers
+separate first-view validation from later pages; OS file caches are uncontrolled.
+Runs alternate baseline/candidate order. One CPU, 8 GiB hard family memory,
+7 GiB early stop, no swap, and a 192-task ceiling bound each serial task.
+Resource counters are observed at payload exit while the observer remains alive;
+final whole-scope counters are unavailable. Kernel cgroup peaks include charged
+file cache and descendants, rather than just the server's JS heap.
+
+## Results and executed validation
+
+Candidate production code: `3930a640fb8387cbd3079eee13fb90f82d1881dc`.
+The [curated receipt](immutable-parent-validation.json) retains every final run,
+offline token estimates, compatibility checks, and costs of previous attempts.
+Values below are medians with min–max ranges across three fresh alternating pairs.
+
+| Source | First page, before → after (ms) | Eight later pages, before → after (ms) |
+| ---------- | ----------------------------------------------------- | -------------------------------------------------- |
+| SQLite ELF | 183.56 [170.13–244.27] → 209.05 [203.11–216.88] | 469.89 [393.47–517.92] → 85.04 [65.10–89.01] |
+| npm | 2441.08 [1681.26–2479.69] → 1978.73 [1864.89–2720.54] | 15534.41 [10378.13–16864.91] → 82.69 [75.19–84.13] |
+| Small ELF | 133.33 [100.81–242.58] → 226.60 [111.79–556.22] | 122.93 [76.38–299.47] → 62.58 [57.69–96.24] |
+
+| Source / runtime | Whole elapsed (s) | Family CPU (s) | Kernel family peak (MiB) |
+| ------------------- | ------------------- | ------------------- | ------------------------ |
+| SQLite ELF / before | 19.08 [15.26–20.00] | 18.75 [15.01–19.55] | 1013.8 [1009.5–1058.6] |
+| SQLite ELF / after | 14.38 [14.06–17.25] | 14.09 [13.77–17.00] | 984.0 [957.1–1047.1] |
+| npm / before | 39.63 [31.21–40.86] | 39.27 [30.87–40.49] | 1338.0 [1301.0–1543.7] |
+| npm / after | 20.71 [20.01–23.02] | 20.50 [19.73–22.23] | 1286.8 [1250.6–1344.9] |
+| Small ELF / before | 14.30 [12.00–17.59] | 13.94 [11.77–17.31] | 1013.2 [937.8–1017.4] |
+| Small ELF / after | 12.31 [11.90–16.25] | 12.04 [11.71–16.07] | 956.3 [931.4–1007.5] |
+
+| Source | Paired warm-read ratio, before / after | Paired first-view change, after − before (ms) |
+| ---------- | -------------------------------------- | --------------------------------------------- |
+| SQLite ELF | 5.53× [4.42–7.96] | +25.49 [-41.16–+46.75] |
+| npm | 184.65× [125.50–224.30] | -462.34 [-614.80–+1039.29] |
+| Small ELF | 1.28× [1.22–5.19] | +10.98 [-15.97–+422.88] |
+
+Each pair matches the before/after runs with the same repetition number.
+The paired effect can differ from the ratio of marginal medians when the host
+speed changes. Positive first-view changes mean higher latency.
+
+The repeated-read benefit is measured per source and pair above. First-view
+validation
+also performs the representation comparison and can be more expensive. Whole
+task, CPU and memory figures above are measured SDK workflow costs, not a
+general provider-analysis or agent-investigation speedup. The previous e30
+checkpoint had a slow npm repetition on both sides, including a 65-second
+candidate task; its cause was not profiled. The original checkpoint and every
+fresh run remain retained. The previous `646312dad` checkpoint also had slower
+small-case warm reads in two of three pairs (135.54 → 373.14 ms marginal
+medians). Those negative results remain available in its linked historical
+receipt; the current cohort improves all three small pairs, without establishing
+a general small-input or whole-task benefit. No model-token saving, general memory improvement,
+or complex-software investigation advantage is established.
+
+All 18 fresh workflow runs preserve original records and canonical answer
+digests. Every corresponding query's structured result and complete catalog
+is equal. The three public CLI source pairs are also byte-for-byte identical.
+The two additional mixed-history tasks preserve all 97 original records, check
+64 follow-up heads over 32 pages and revision two, reject stale updates and
+tampered imports atomically, clear Unknowns on close, and refuse old references.
+
+Offline `tiktoken` 0.12.0 / `cl100k_base` estimates for one pass over the complete
+catalog, named-call arguments and replies are **unchanged** within each pair:
+849,736 native, 856,384 JavaScript, and 840,303 small-case tokens. The catalog
+contributes 805,215 tokens alone.
+These are raw transport serialization estimates, not actual model context or
+usage; initialization/framing, prompts, client discovery, rendering/replay,
+and continuations are unmeasured. Metadata paths differ from the historical
+checkpoint; compare equivalent runs within each checkpoint.
+
+Executed checks at the final production code:
+
+- `npm run check` and `npm run docs:check`: pass, including five README
+ consistency tests.
+- Three latest-main integration files through `npm run test:focused`, using
+ default deadlines: 27 tests pass at the current production source.
+- 130 source tests across immutable JSON, native/JavaScript format validation,
+ and the shared application view service; `npm run check:fast` and
+ `npm run build:cached` pass.
+- Four compiled CLI/MCP files (`evidenceBundleInline`, `serverUnknownsMcp`,
+ `analysisViewMcp`, and `analysisViewCli`): 36 tests pass.
+- Real public stdio MCP: 18 fresh paired tasks and two additional mixed tasks;
+ public CLI: six invocations, with three exact output pairs. These corpus
+ workflows and four-file boundary checks have exit zero, verified payload
+ cleanup and zero observed payload-exit OOM events.
+
+Internal and automated review reproduced **candidate-only** defects before integration.
+Generic deep equality ignored hidden fields removed by parsing; the JSON owner
+comparison now preserves that normalization. Review also reproduced aliases crossing
+preserved subtrees and cloned metadata; four regressions failed against the prior
+source. The comparer now visits preserved descendants with two-way identity mapping.
+Already-owned JavaScript graphs keep their parsed-metadata fast path, so the generic
+comparison and full-result cache only apply to the expensive imported fallback. Its
+initial iterative traversal
+also repeatedly expanded shared nodes: a valid 27-object graph exhausted an
+instrumented 10,000-inspection budget. Tracking source-to-parsed node pairs
+reduces that same compiled probe to 54 inspections and successful borrowing.
+A parser that splits or merges source nodes keeps its parsed result rather than
+expanding repeated paths. Deterministic regressions enforce the inspection
+budget instead of relying on timing or letting a regression consume exponential
+CPU. These are internal JSON-owner probes, not claimed baseline public-provider
+reproductions.
+
+The initial exploratory cohort and historical e30 paired checkpoint are not
+the final comparison. One earlier source-check attempt was mistakenly started
+during an initial baseline run; the newly started owned scope was stopped after
+17.27 s and that check remains incomplete (exit 241). Observed counters, the
+contended baseline, subsequent successful retries, and prior checkpoints remain
+retained; no OOM or terminal-counter claim is inferred from that stopped task.
+Two later tasks stopped because the host-available-memory guard reported its
+early-stop condition: candidate JavaScript repetition three and baseline small
+repetition three. Both incomplete attempts and the unmatched completed
+JavaScript baseline remain separate. After memory recovered, both sides were
+rerun as fresh pair four; final JavaScript and small samples use pairs 1, 2, 4.
+Neither interrupted task is a completed comparison. The guard later gained
+read-only host-memory/cgroup receipt fields; all resource thresholds and its
+observer/stop logic remained unchanged.
+
+Real Ghidra, Hopper, JEB, fresh JavaScript producer performance, and actual
+agent trials are outside this checkpoint. Private WeakSet metadata/heap retention
+was not measured independently; the absence of a strong retained parsed graph
+is source-derived. The comparison maps exist only during the first
+interpretation; measured family
+peaks include their temporary cost.
+
+## Latest-main integration and an unexplained timeout
+
+Merge `71e0b2739` brings in main `bb212ffec`'s three test/config/guide fixes.
+The current source passes all 27 tests in those three integration files through
+`npm run test:focused` with the default deadlines. The earlier `646312dad`
+checkpoint initially passed 26 and timed out the live identity/catalog test at
+30 seconds. Matching official-command controls subsequently passed all 27 on
+both unmodified main and that candidate. Direct/extended-deadline diagnostics
+are recorded separately. Their passing results do not establish the cause of
+the original timeout, which remains preserved and unexplained. No test-policy
+or product file was changed to obtain a pass.
+
+## Reproduction and retained evidence
+
+Use `retained-investigation.mjs` from this directory with an authentic exported
+bundle and its original source Evidence ID. Build both selected runtime revisions
+with the pinned toolchain, preserving a separate baseline. For each runtime run:
+
+```sh
+python3 experiments/analysis-efficiency/resource-run.py --observe-payload-exit -- \
+ node experiments/analysis-efficiency/retained-investigation.mjs \
+ --runtime-root /absolute/runtime --revision REVISION \
+ --bundle /absolute/history.json --evidence-id ORIGINAL_EVIDENCE_ID \
+ --scenario native --delivery focused --output /absolute/new-receipt-directory
+```
+
+Use `--scenario javascript` for the npm history, and `--verify-mixed` with an
+actual mixed investigation. Reuse the same bytes and source identity on both
+sides. Do not regenerate parent identities or synthesize bundle records.
+The checked-in wrapper defaults to a 4 GiB hard / 3 GiB early stop. This
+checkpoint used a private resource-only copy with 8 GiB / 7 GiB thresholds,
+a 16 GiB available-memory start floor and 8 GiB host early stop. Its source
+and unchanged observer hashes are recorded in the curated receipt. This local
+resource policy does not change the public workflow or global wrapper defaults.
+Raw histories, transcripts, oracle outputs, and resource logs stay in the private
+local audit cache; only curated receipts are committed.
diff --git a/src/application/analysisView/AnalysisViewService.test.ts b/src/application/analysisView/AnalysisViewService.test.ts
index 302302ee2..958db14b0 100644
--- a/src/application/analysisView/AnalysisViewService.test.ts
+++ b/src/application/analysisView/AnalysisViewService.test.ts
@@ -25,6 +25,36 @@ import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
import { err, ok } from "../../domain/result.js";
import { EvidenceLedger } from "../investigation/EvidenceLedger.js";
import { WEB_NETWORK_CAPTURE_LIMITS } from "../../domain/webNetworkCapture.js";
+import { isImmutableJsonSnapshot } from "../../domain/immutableJson.js";
+
+it.each(["layout", "javascript"])(
+ "carries the retained %s source snapshot into repeatable shared views",
+ (kind) => {
+ const parent =
+ kind === "layout"
+ ? analysisViewLayoutEvidence()
+ : analysisViewJavaScriptEvidence();
+ const ledger = new EvidenceLedger();
+ const recorded = ledger.record(parent);
+ if (!recorded.ok) throw recorded.error;
+ const borrowed = ledger.forAnalysis(parent.evidence_id)!;
+ const original = JSON.stringify(borrowed);
+ const input = {
+ source: { kind: "retained-evidence", evidence_id: parent.evidence_id },
+ view: { kind: "summary" },
+ } as const;
+ const first = inspectAnalysisView(input, (id) => ledger.forAnalysis(id));
+ if (!first.ok) throw first.error;
+ const repeated = inspectAnalysisView(input, (id) => ledger.forAnalysis(id));
+ if (!repeated.ok) throw repeated.error;
+ expect(repeated.value.normalized_result).toEqual(
+ first.value.normalized_result,
+ );
+ expect(isImmutableJsonSnapshot(borrowed.normalized_result)).toBe(true);
+ expect(JSON.stringify(borrowed)).toBe(original);
+ expect(ledger.forAnalysis(parent.evidence_id)).toBe(borrowed);
+ },
+);
it.each(["/fixtures/unknown.exe", ""])(
"preserves recorded empty native identity fields: path=%j",
diff --git a/src/application/analysisView/AnalysisViewService.ts b/src/application/analysisView/AnalysisViewService.ts
index 5016b357e..1bc09eae0 100644
--- a/src/application/analysisView/AnalysisViewService.ts
+++ b/src/application/analysisView/AnalysisViewService.ts
@@ -21,7 +21,10 @@ import {
type InspectAnalysisViewInput,
} from "../../domain/analysisView/analysisView.js";
import { jsonValueSchema } from "../../domain/jsonValue.js";
-import { isImmutableJsonSnapshot } from "../../domain/immutableJson.js";
+import {
+ immutableJsonSnapshotMember,
+ isImmutableJsonSnapshot,
+} from "../../domain/immutableJson.js";
import { err, ok, type Result } from "../../domain/result.js";
import { WebNetworkApiSurfaceAccumulator } from "../../domain/analysisView/WebNetworkApiSurfaceAccumulator.js";
import { admitAnalysisViewData } from "../../domain/analysisView/analysisViewDataAdmission.js";
@@ -70,7 +73,9 @@ export const inspectAnalysisViewValidated = (
{
evidenceId: parent.evidence_id,
operation: parent.operation,
- normalizedResult: parent.normalized_result,
+ normalizedResult:
+ immutableJsonSnapshotMember(parent, "normalized_result") ??
+ parent.normalized_result,
// Sealing an Evidence root deep-freezes it; only the root is registered.
sealedResult: isImmutableJsonSnapshot(parent),
subject: parent.subject,
diff --git a/src/domain/analysisView/analysisView.ts b/src/domain/analysisView/analysisView.ts
index c6693ba24..fce662060 100644
--- a/src/domain/analysisView/analysisView.ts
+++ b/src/domain/analysisView/analysisView.ts
@@ -10,10 +10,7 @@ import {
} from "./javascriptFactsView.js";
import { javaScriptSourceSelectionSchema } from "../javascript/javascriptSourceSelection.js";
-import {
- AnalysisInputError,
- AnalysisUnsupportedTargetError,
-} from "../analysisErrorCore.js";
+import { AnalysisUnsupportedTargetError } from "../analysisErrorCore.js";
import {
INSPECT_ANALYSIS_VIEW_OPERATION,
analysisViewInputError,
@@ -24,7 +21,7 @@ import { evidenceSchema, type Evidence } from "../evidence.js";
import { jsonObjectSchema, jsonValueSchema } from "../jsonValue.js";
import { err, ok, type Result } from "../result.js";
import type { AnalysisError } from "../analysisErrorBase.js";
-import { binaryLayoutSchema } from "../native/binaryLayout.js";
+import { safeParseOwnedBinaryLayout } from "../native/binaryLayout.js";
import { functionDossierSchema } from "../hopperValues.js";
import {
artifactGraphManifestSchema,
@@ -741,8 +738,8 @@ const parseJavaScriptParent = (
input: unknown,
): Result<JavaScriptApplicationAnalysisResult, AnalysisError> => {
try {
- // Only the existing realm-private graph proofs permit reuse. Imported or
- // merely frozen graphs still receive full canonical validation.
+ // The format owner authenticates imported results completely before reuse;
+ // mutable or merely frozen inputs still receive canonical validation.
const steps = parseOwnedJavaScriptApplicationAnalysisSteps(input);
let step = steps.next();
while (!step.done) step = steps.next();
@@ -841,7 +838,7 @@ export const projectAnalysisView = (
return projected.ok ? ok(sealAnalysisView(projected.value)) : projected;
}
if (parent.operation === "inspect_binary_layout") {
- const layout = binaryLayoutSchema.safeParse(parent.normalizedResult);
+ const layout = safeParseOwnedBinaryLayout(parent.normalizedResult);
if (!layout.success)
return err(
analysisViewInputError([
diff --git a/src/domain/immutableJson.test.ts b/src/domain/immutableJson.test.ts
index 16e524a96..068192f10 100644
--- a/src/domain/immutableJson.test.ts
+++ b/src/domain/immutableJson.test.ts
@@ -1,12 +1,55 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
import type { JsonValue } from "./jsonValue.js";
import {
freezeJsonSnapshot,
+ canBorrowParsedJsonSnapshot,
+ immutableJsonSnapshotMember,
isImmutableJsonSnapshot,
} from "./immutableJson.js";
describe("owned immutable JSON snapshots", () => {
+ it("borrows only the selected own child of a completed sealed root", () => {
+ const value = freezeJsonSnapshot({
+ selected: { values: [1, 2] },
+ other: { value: 3 },
+ absent: null,
+ });
+ expect(isImmutableJsonSnapshot(value.selected)).toBe(false);
+ expect(immutableJsonSnapshotMember(value, "selected")).toBe(value.selected);
+ expect(isImmutableJsonSnapshot(value.selected)).toBe(true);
+ expect(isImmutableJsonSnapshot(value.other)).toBe(false);
+ expect(immutableJsonSnapshotMember(value.selected, "values")).toBe(
+ value.selected.values,
+ );
+ expect(isImmutableJsonSnapshot(value.selected.values)).toBe(true);
+ expect(immutableJsonSnapshotMember(value, "absent")).toBeNull();
+ expect(immutableJsonSnapshotMember(value, "missing")).toBeUndefined();
+ expect(immutableJsonSnapshotMember(value, "toString")).toBeUndefined();
+ expect(Reflect.set(value.selected.values, 0, 9)).toBe(false);
+ });
+
+ it("does not borrow children from unowned roots or invoke their accessors", () => {
+ let accessed = false;
+ const child = Object.freeze({ value: 1 });
+ const root = Object.freeze({ child });
+ expect(immutableJsonSnapshotMember(root, "child")).toBeUndefined();
+ expect(isImmutableJsonSnapshot(child)).toBe(false);
+ expect(
+ immutableJsonSnapshotMember(
+ {
+ get child() {
+ accessed = true;
+ return child;
+ },
+ },
+ "child",
+ ),
+ ).toBeUndefined();
+ expect(accessed).toBe(false);
+ expect(immutableJsonSnapshotMember(null, "child")).toBeUndefined();
+ });
+
it("seals reachable data and preserves repeated references", () => {
const shared = { values: [1, "observed"] };
const value = { left: shared, right: shared };
@@ -61,4 +104,166 @@ describe("owned immutable JSON snapshots", () => {
"JSON values",
);
});
+
+ it("rejects proxy snapshots before reflecting on their mutable behavior", () => {
+ let reflected = false;
+ const proxy = new Proxy(
+ { value: 1 },
+ {
+ getPrototypeOf() {
+ reflected = true;
+ throw new Error("must not reflect on a proxy");
+ },
+ },
+ );
+ const root = { child: proxy };
+ for (const input of [proxy, root]) {
+ expect(() => freezeJsonSnapshot(input)).toThrow("proxies");
+ expect(isImmutableJsonSnapshot(input)).toBe(false);
+ }
+ expect(Object.isFrozen(root)).toBe(false);
+ expect(reflected).toBe(false);
+ });
+});
+
+describe("borrowing a parsed JSON snapshot", () => {
+ it("accepts reordered object fields but preserves arrays and exact scalars", () => {
+ const source = freezeJsonSnapshot({ second: [true, null], first: -0 });
+ expect(
+ canBorrowParsedJsonSnapshot(source, { first: -0, second: [true, null] }),
+ ).toBe(true);
+ expect(
+ canBorrowParsedJsonSnapshot(source, { first: 0, second: [true, null] }),
+ ).toBe(false);
+ expect(
+ canBorrowParsedJsonSnapshot(source, { first: -0, second: [null, true] }),
+ ).toBe(false);
+ expect(
+ canBorrowParsedJsonSnapshot(Object.freeze({ value: 1 }), { value: 1 }),
+ ).toBe(false);
+ });
+
+ it("preserves parser defaults, hidden-field removal and enumerability changes", () => {
+ const source = freezeJsonSnapshot({ observed: 1 });
+ expect(
+ canBorrowParsedJsonSnapshot(source, { observed: 1, defaulted: 0 }),
+ ).toBe(false);
+ const hidden = { observed: 1 };
+ Object.defineProperty(hidden, "unmodeled", { value: 2, enumerable: false });
+ freezeJsonSnapshot(hidden);
+ expect(canBorrowParsedJsonSnapshot(hidden, { observed: 1 })).toBe(false);
+ const nonenumerable = { observed: 1 };
+ Object.defineProperty(nonenumerable, "observed", { enumerable: false });
+ freezeJsonSnapshot(nonenumerable);
+ expect(canBorrowParsedJsonSnapshot(nonenumerable, { observed: 1 })).toBe(
+ false,
+ );
+ });
+
+ it("does not evaluate accessors introduced by a parsed representation", () => {
+ let accessed = false;
+ const source = freezeJsonSnapshot({ observed: 1 });
+ expect(
+ canBorrowParsedJsonSnapshot(source, {
+ get observed() {
+ accessed = true;
+ return 1;
+ },
+ }),
+ ).toBe(false);
+ expect(accessed).toBe(false);
+ });
+
+ it("declines parser-introduced proxies without reflecting on them", () => {
+ let reflected = false;
+ const parsed = new Proxy(
+ { value: 1 },
+ {
+ getPrototypeOf() {
+ reflected = true;
+ throw new Error("must not reflect on a proxy");
+ },
+ },
+ );
+ expect(
+ canBorrowParsedJsonSnapshot(freezeJsonSnapshot({ value: 1 }), parsed),
+ ).toBe(false);
+ expect(reflected).toBe(false);
+ });
+
+ it("compares deeply nested snapshots without depending on the call stack", () => {
+ let source: JsonValue = 1;
+ let parsed: JsonValue = 1;
+ for (let depth = 0; depth < 6_000; depth += 1) {
+ source = { child: source };
+ parsed = { child: parsed };
+ }
+ freezeJsonSnapshot(source);
+ expect(canBorrowParsedJsonSnapshot(source, parsed)).toBe(true);
+ });
+
+ it("compares shared snapshot graphs without repeatedly expanding their paths", () => {
+ let source: JsonValue = { value: 1 };
+ for (let depth = 0; depth < 26; depth += 1)
+ source = { left: source, right: source };
+ const parsed = structuredClone(source);
+ freezeJsonSnapshot(source);
+ const ownKeys = Reflect.ownKeys;
+ let inspections = 0;
+ const observed = vi
+ .spyOn(Reflect, "ownKeys")
+ .mockImplementation((value) => {
+ // Fail deterministically instead of consuming exponential CPU on regressions.
+ if (++inspections > 10_000)
+ throw new Error("Shared JSON comparison exceeded inspection budget");
+ return ownKeys(value);
+ });
+ let borrowed: boolean;
+ try {
+ borrowed = canBorrowParsedJsonSnapshot(source, parsed);
+ } finally {
+ observed.mockRestore();
+ }
+ expect(borrowed).toBe(true);
+ });
+
+ it("keeps the parsed result when a parser splits shared source nodes", () => {
+ const shared = { value: 1 };
+ const source = freezeJsonSnapshot({ left: shared, right: shared });
+ expect(
+ canBorrowParsedJsonSnapshot(source, {
+ left: { value: 1 },
+ right: { value: 1 },
+ }),
+ ).toBe(false);
+ });
+
+ it.each(["direct", "nested"])(
+ "detects shared-node splits across a %s preserved subtree",
+ (kind) => {
+ const shared = { value: 1 };
+ const source = freezeJsonSnapshot({
+ preserved: kind === "direct" ? shared : { nested: shared },
+ cloned: shared,
+ });
+ expect(
+ canBorrowParsedJsonSnapshot(source, {
+ preserved: source.preserved,
+ cloned: { value: 1 },
+ }),
+ ).toBe(false);
+ expect(canBorrowParsedJsonSnapshot(source, source)).toBe(true);
+ },
+ );
+
+ it("keeps the parsed result when a parser merges distinct source nodes", () => {
+ const source = freezeJsonSnapshot({
+ left: { value: 1 },
+ right: { value: 1 },
+ });
+ const shared = { value: 1 };
+ expect(
+ canBorrowParsedJsonSnapshot(source, { left: shared, right: shared }),
+ ).toBe(false);
+ });
});
diff --git a/src/domain/immutableJson.ts b/src/domain/immutableJson.ts
index 0b68b4e2b..afe846221 100644
--- a/src/domain/immutableJson.ts
+++ b/src/domain/immutableJson.ts
@@ -1,3 +1,5 @@
+import { isProxy } from "node:util/types";
+
import type { JsonValue } from "./jsonValue.js";
const immutableSnapshots = new WeakSet<object>();
@@ -14,6 +16,87 @@ export const isImmutableJsonSnapshot = (value: unknown): value is JsonValue =>
(typeof value === "number" && Number.isFinite(value)) ||
(typeof value === "object" && immutableSnapshots.has(value));
+/** Borrow one own member of a completed snapshot, carrying its sealing proof. */
+export const immutableJsonSnapshotMember = (
+ snapshot: unknown,
+ key: string,
+): JsonValue | undefined => {
+ if (
+ typeof snapshot !== "object" ||
+ snapshot === null ||
+ !immutableSnapshots.has(snapshot)
+ )
+ return undefined;
+ const descriptor = Object.getOwnPropertyDescriptor(snapshot, key);
+ if (descriptor === undefined || !Object.hasOwn(descriptor, "value"))
+ return undefined;
+ // Completed sealing checked and froze every reachable member. Register only
+ // the selected child; do not traverse it again or add per-node weak entries.
+ const member = descriptor.value as JsonValue;
+ if (typeof member === "object" && member !== null)
+ immutableSnapshots.add(member);
+ return member;
+};
+
+/** Match a completed snapshot to its parsed representation without recursion. */
+export const canBorrowParsedJsonSnapshot = <Parsed extends JsonValue>(
+ source: unknown,
+ parsed: Parsed,
+): source is Parsed => {
+ if (!isImmutableJsonSnapshot(source)) return false;
+ if (Object.is(source, parsed)) return true;
+ const pending: unknown[] = [source, parsed];
+ const compared = new Map<object, object>();
+ const sources = new Map<object, object>();
+ while (pending.length > 0) {
+ const right = pending.pop();
+ const left = pending.pop();
+ if (
+ typeof left !== "object" ||
+ left === null ||
+ typeof right !== "object" ||
+ right === null
+ ) {
+ if (!Object.is(left, right)) return false;
+ continue;
+ }
+ if (
+ isProxy(right) ||
+ Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)
+ )
+ return false;
+ const previous = compared.get(left);
+ if (previous !== undefined) {
+ if (previous !== right) return false;
+ continue;
+ }
+ if (sources.has(right)) return false;
+ // Preserve sharing in both directions, including descendants of an
+ // identical subtree that may also appear in a separately parsed field.
+ compared.set(left, right);
+ sources.set(right, left);
+ const keys = Reflect.ownKeys(left);
+ if (keys.length !== Reflect.ownKeys(right).length) return false;
+ for (const key of keys) {
+ // A parser may drop hidden fields or normalize enumerability. Generic
+ // deep equality omits these differences and can borrow unparsed data.
+ if (typeof key !== "string") return false;
+ const a = Object.getOwnPropertyDescriptor(left, key);
+ const b = Object.getOwnPropertyDescriptor(right, key);
+ if (
+ a === undefined ||
+ b === undefined ||
+ !Object.hasOwn(a, "value") ||
+ !Object.hasOwn(b, "value") ||
+ a.enumerable !== b.enumerable
+ )
+ return false;
+ pending.push(a.value as unknown, b.value as unknown);
+ }
+ }
+ return true;
+};
+
/** Seal an already parsed, owned JSON snapshot for immutable zero-copy reuse. */
export const freezeJsonSnapshot = <T extends JsonValue>(value: T): T => {
const pending: SnapshotEntry[] = [{ value, exiting: false }];
@@ -104,6 +187,8 @@ export function* freezeOwnedJsonSnapshotSteps<T extends JsonValue>(
}
const pushSnapshotChildren = (item: object, pending: SnapshotEntry[]): void => {
+ if (isProxy(item))
+ throw new TypeError("Immutable JSON snapshots cannot contain proxies");
const prototype: unknown = Object.getPrototypeOf(item);
if (
!Array.isArray(item) &&
diff --git a/src/domain/immutableJsonSteps.test.ts b/src/domain/immutableJsonSteps.test.ts
index 0755e75f0..d42652566 100644
--- a/src/domain/immutableJsonSteps.test.ts
+++ b/src/domain/immutableJsonSteps.test.ts
@@ -1,6 +1,7 @@
import { describe, expect, it } from "vitest";
import {
freezeOwnedJsonSnapshotSteps,
+ immutableJsonSnapshotMember,
isImmutableJsonSnapshot,
} from "./immutableJson.js";
import { jsonValueValidationIssue, type JsonValue } from "./jsonValue.js";
@@ -23,6 +24,7 @@ describe("cooperative owned snapshot sealing", () => {
expect(steps.next().done).toBe(false);
expect(Object.isFrozen(value)).toBe(true);
expect(isImmutableJsonSnapshot(value)).toBe(false);
+ expect(immutableJsonSnapshotMember(value, "deferred")).toBeUndefined();
const introduced = { value: 2 };
deferred.child = introduced;
expect(complete(steps)).toBe(value);
@@ -49,6 +51,7 @@ describe("cooperative owned snapshot sealing", () => {
expect(interrupted.next().done).toBe(false);
interrupted.return(cancelled);
expect(isImmutableJsonSnapshot(cancelled)).toBe(false);
+ expect(immutableJsonSnapshotMember(cancelled, "values")).toBeUndefined();
});
it("preserves aliases and rejects accessors, sparse values and cycles", () => {
@@ -80,4 +83,26 @@ describe("cooperative owned snapshot sealing", () => {
value.child.value = Number.NaN;
expect(jsonValueValidationIssue(value)).toBe("JSON numbers must be finite");
});
+
+ it("never authenticates roots containing proxies or invokes their traps", () => {
+ let reflected = false;
+ const proxy = new Proxy(
+ { value: 1 },
+ {
+ getPrototypeOf() {
+ reflected = true;
+ throw new Error("must not reflect on a proxy");
+ },
+ },
+ );
+ const root = { child: proxy };
+ for (const input of [proxy, root]) {
+ expect(() => complete(freezeOwnedJsonSnapshotSteps(input))).toThrow(
+ "proxies",
+ );
+ expect(isImmutableJsonSnapshot(input)).toBe(false);
+ expect(immutableJsonSnapshotMember(input, "child")).toBeUndefined();
+ }
+ expect(reflected).toBe(false);
+ });
});
diff --git a/src/domain/javascript/javascriptApplicationAnalysis.ts b/src/domain/javascript/javascriptApplicationAnalysis.ts
index 7b1055b79..adda5c31b 100644
--- a/src/domain/javascript/javascriptApplicationAnalysis.ts
+++ b/src/domain/javascript/javascriptApplicationAnalysis.ts
@@ -1,4 +1,5 @@
import { z } from "zod";
+import { canBorrowParsedJsonSnapshot } from "../immutableJson.js";
import {
javascriptApplicationGraphSchema,
@@ -172,21 +173,43 @@ const ownedAnalysisResultShape = applicationAnalysisResultShape.extend({
),
});
+// One successful interpretation per exact immutable source. Weak keys retain
+// neither a second graph nor a source beyond its Evidence lifetime.
+const validatedImmutableResults = new WeakSet<object>();
+const isValidatedImmutableResult = (
+ input: unknown,
+): input is JavaScriptApplicationAnalysisResult =>
+ typeof input === "object" &&
+ input !== null &&
+ validatedImmutableResults.has(input);
+
/** Reuse exact owned graphs while validating metadata and cross-graph bindings. */
export function* parseOwnedJavaScriptApplicationAnalysisSteps(
input: unknown,
): Generator<void, JavaScriptApplicationAnalysisResult> {
+ if (isValidatedImmutableResult(input)) return input;
const prepared = ownedAnalysisResultShape.safeParse(input);
- if (!prepared.success)
- return javascriptApplicationAnalysisResultSchema.parse(input);
- const issues: BindingIssue[] = [];
- yield* checkApplicationBindingsSteps(prepared.data, {
- addIssue: (issue) => {
- issues.push(issue);
- },
- });
- if (issues.length > 0) throw new z.ZodError(issues);
- return prepared.data;
+ if (prepared.success) {
+ const issues: BindingIssue[] = [];
+ yield* checkApplicationBindingsSteps(prepared.data, {
+ addIssue: (issue) => {
+ issues.push(issue);
+ },
+ });
+ if (issues.length > 0) throw new z.ZodError(issues);
+ // Keep this existing fast path and its metadata normalization. Rewalking
+ // already owned graphs just to borrow the wrapper would add full-graph work.
+ return prepared.data;
+ }
+ const result = javascriptApplicationAnalysisResultSchema.parse(input);
+ // Borrow only if parsing preserved the exact representation. A future schema
+ // default/normalization must still return its parsed value, without caching.
+ // Admission follows full validation, including completion of yielding checks.
+ if (canBorrowParsedJsonSnapshot(input, result)) {
+ validatedImmutableResults.add(input);
+ return input;
+ }
+ return result;
}
/** Parsed public JavaScript application analysis request. */
diff --git a/src/domain/javascript/javascriptApplicationAnalysisSteps.test.ts b/src/domain/javascript/javascriptApplicationAnalysisSteps.test.ts
index 6356f92c0..d754a9897 100644
--- a/src/domain/javascript/javascriptApplicationAnalysisSteps.test.ts
+++ b/src/domain/javascript/javascriptApplicationAnalysisSteps.test.ts
@@ -56,6 +56,101 @@ const issuesFrom = (action: () => unknown) => {
throw new Error("Expected complete result validation to reject the input");
};
+describe("immutable JavaScript result reuse", () => {
+ it("preserves parser copies shared across owned graphs and result metadata", () => {
+ const owned = ownedExample();
+ const input = freezeJsonSnapshot({
+ ...owned,
+ limitations: owned.graph.limitations,
+ });
+ for (let repeat = 0; repeat < 2; repeat += 1) {
+ const parsed = complete(
+ parseOwnedJavaScriptApplicationAnalysisSteps(input),
+ );
+ expect(parsed).not.toBe(input);
+ expect(parsed.graph).toBe(input.graph);
+ expect(parsed.limitations).toEqual(input.graph.limitations);
+ expect(parsed.limitations).not.toBe(parsed.graph.limitations);
+ }
+ });
+
+ it.each(["hidden-extra", "changed-enumerability"])(
+ "preserves parsed results when the source has %s normalization",
+ (kind) => {
+ const input = example();
+ if (kind === "hidden-extra")
+ Object.defineProperty(input, "not_in_parsed_result", {
+ value: { unvalidated: true },
+ enumerable: false,
+ });
+ else Object.defineProperty(input, "input_path", { enumerable: false });
+ freezeJsonSnapshot(input);
+ const expected = javascriptApplicationAnalysisResultSchema.parse(input);
+ for (let repeat = 0; repeat < 2; repeat += 1) {
+ const parsed = complete(
+ parseOwnedJavaScriptApplicationAnalysisSteps(input),
+ );
+ expect(parsed).not.toBe(input);
+ expect(Object.hasOwn(parsed, "not_in_parsed_result")).toBe(false);
+ expect(
+ Object.getOwnPropertyDescriptor(parsed, "input_path")?.enumerable,
+ ).toBe(
+ Object.getOwnPropertyDescriptor(expected, "input_path")?.enumerable,
+ );
+ }
+ },
+ );
+
+ it("borrows imported immutable results only after complete format validation", () => {
+ const input = example();
+ delete input.statistics.skipped_javascript_files;
+ freezeJsonSnapshot(input);
+ const result = complete(
+ parseOwnedJavaScriptApplicationAnalysisSteps(input),
+ );
+ expect(result).toBe(input);
+ expect(result).toEqual(
+ javascriptApplicationAnalysisResultSchema.parse(input),
+ );
+ expect(result.statistics).not.toHaveProperty("skipped_javascript_files");
+ expect(complete(parseOwnedJavaScriptApplicationAnalysisSteps(input))).toBe(
+ input,
+ );
+ expect(Reflect.set(input.statistics, "findings", -1)).toBe(false);
+ });
+
+ it("preserves a normalized representation instead of borrowing changed input", () => {
+ const input = example();
+ Object.setPrototypeOf(input, null);
+ freezeJsonSnapshot(input);
+ for (let repeat = 0; repeat < 2; repeat += 1) {
+ const result = complete(
+ parseOwnedJavaScriptApplicationAnalysisSteps(input),
+ );
+ expect(result).not.toBe(input);
+ expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+ expect(result).toEqual(
+ javascriptApplicationAnalysisResultSchema.parse(input),
+ );
+ }
+ });
+
+ it.each(["mutable", "shallow-frozen"])(
+ "rechecks changed %s metadata despite authenticated nested graphs",
+ (kind) => {
+ const input = ownedExample();
+ if (kind === "shallow-frozen") Object.freeze(input);
+ expect(
+ complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
+ ).not.toBe(input);
+ input.statistics.findings = -1;
+ expect(() =>
+ complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
+ ).toThrow(z.ZodError);
+ },
+ );
+});
+
describe("owned JavaScript graph validation", () => {
it("reuses exact sealed graphs and preserves all public result fields", () => {
const input = ownedExample();
@@ -239,6 +334,7 @@ describe("owned JavaScript result bindings", () => {
input.semantic_graph = complete(
createImmutableJavaScriptSemanticGraphSteps(semantic),
);
+ freezeJsonSnapshot(input);
const steps = parseOwnedJavaScriptApplicationAnalysisSteps(input);
expect(steps.next().done).toBe(false);
steps.return(input);
diff --git a/src/domain/native/binaryLayout.test.ts b/src/domain/native/binaryLayout.test.ts
index 9f8f970e0..49b26d417 100644
--- a/src/domain/native/binaryLayout.test.ts
+++ b/src/domain/native/binaryLayout.test.ts
@@ -1,5 +1,10 @@
import { expect, it } from "vitest";
-import { binaryLayoutSchema, type BinaryLayout } from "./binaryLayout.js";
+import {
+ binaryLayoutSchema,
+ safeParseOwnedBinaryLayout,
+ type BinaryLayout,
+} from "./binaryLayout.js";
+import { freezeJsonSnapshot } from "../immutableJson.js";
const report = () => ({
artifact: { path: "/fixture.elf", sha256: "a".repeat(64), bytes: 128 },
@@ -60,6 +65,55 @@ const report = () => ({
limitations: [],
});
+it("reuses an exact validated immutable layout without a second retained copy", () => {
+ const value = freezeJsonSnapshot(report());
+ const parsed = safeParseOwnedBinaryLayout(value);
+ expect(parsed.success).toBe(true);
+ if (!parsed.success) throw parsed.error;
+ expect(parsed.data).toBe(value);
+ expect(safeParseOwnedBinaryLayout(value)).toEqual(parsed);
+ expect(parsed.data).toEqual(binaryLayoutSchema.parse(value));
+ expect(Reflect.set(value.sections[0]!, "index", 5)).toBe(false);
+});
+
+it.each(["mutable", "shallow-frozen"])(
+ "revalidates a changed %s layout instead of caching its former validity",
+ (kind) => {
+ const value = report();
+ if (kind === "shallow-frozen") Object.freeze(value);
+ const first = safeParseOwnedBinaryLayout(value);
+ if (!first.success) throw first.error;
+ expect(first.data).not.toBe(value);
+ value.sections[0]!.header_location.offset = "0x80";
+ const invalid = safeParseOwnedBinaryLayout(value);
+ expect(invalid.success).toBe(false);
+ expect(invalid).toEqual(binaryLayoutSchema.safeParse(value));
+ },
+);
+
+it("never treats sealing as format validity or caches a refused layout", () => {
+ const value = report();
+ value.sections[0]!.index = 10;
+ freezeJsonSnapshot(value);
+ expect(safeParseOwnedBinaryLayout(value).success).toBe(false);
+ expect(safeParseOwnedBinaryLayout(value).success).toBe(false);
+});
+
+it("does not borrow hidden fields that the format parser removed", () => {
+ const value = report();
+ Object.defineProperty(value, "not_in_parsed_result", {
+ value: { unvalidated: true },
+ enumerable: false,
+ });
+ freezeJsonSnapshot(value);
+ for (let repeat = 0; repeat < 2; repeat += 1) {
+ const parsed = safeParseOwnedBinaryLayout(value);
+ if (!parsed.success) throw parsed.error;
+ expect(parsed.data).not.toBe(value);
+ expect(Object.hasOwn(parsed.data, "not_in_parsed_result")).toBe(false);
+ }
+});
+
it("retains high linked values and NOBITS without inventing file backing", () => {
const value = binaryLayoutSchema.parse(report());
expect(value.entry_point.reported_value).toBe("0x20000000000001");
diff --git a/src/domain/native/binaryLayout.ts b/src/domain/native/binaryLayout.ts
index 62ebb34f2..cc37376dd 100644
--- a/src/domain/native/binaryLayout.ts
+++ b/src/domain/native/binaryLayout.ts
@@ -1,4 +1,5 @@
import { z } from "zod";
+import { canBorrowParsedJsonSnapshot } from "../immutableJson.js";
import { localPathStringSchema } from "../localPath.js";
import { CANONICAL_BASE64_PATTERN } from "../stringPatterns.js";
@@ -316,6 +317,28 @@ export type InspectBinaryLayoutInput = z.infer<
>;
export type BinaryLayout = z.infer<typeof binaryLayoutSchema>;
+const validatedImmutableLayouts = new WeakSet<object>();
+
+/** Validate once per exact immutable source; mutable inputs always revalidate. */
+export const safeParseOwnedBinaryLayout = (
+ input: unknown,
+): z.ZodSafeParseResult<BinaryLayout> => {
+ if (
+ typeof input === "object" &&
+ input !== null &&
+ validatedImmutableLayouts.has(input)
+ )
+ return { success: true, data: input as BinaryLayout };
+ const parsed = binaryLayoutSchema.safeParse(input);
+ if (parsed.success && canBorrowParsedJsonSnapshot(input, parsed.data)) {
+ // Preserve normalization if the schema changes: only unchanged, completely
+ // validated data can be borrowed without retaining a duplicate layout.
+ validatedImmutableLayouts.add(input);
+ return { success: true, data: input };
+ }
+ return parsed;
+};
+
const validateRelocationReferences = (
value: z.output<typeof binaryLayoutObjectSchema>,
context: z.RefinementCtx,