Compiler-Memory Release Integration

Compiler-memory optimization is release-ready only when implementation

evidence, public support status, artifact manifests, limitations, and explicit

heavy-gate policy all agree.

Run the bounded release integration gate with:

make compiler-memory-release-check

This gate validates source-owned evidence and earlier bounded compiler-memory

gates. It does not run self-hosting, full release verification, remote

deployment, broad benchmark sweeps, or hardware/emulator matrices.

Release Evidence

The gate reads these source files:

• compiler-memory-release/final-gates.tsv;
• compiler-memory-release/support-matrix.tsv;
• compiler-memory-release/artifact-manifest.tsv;
• compiler-memory-release/heavy-gate-plan.tsv;
• compiler-memory-release/limitations.tsv;
• compiler-memory-release/operator-developer-guide.tsv;
• compiler-memory-release/diagnostics.tsv;
• compiler-memory-release/verification-cases.tsv;
• release/compiler-memory-release-decision.tsv;
• release/compiler-memory-release-artifacts.tsv;
• release/compiler-memory-support-matrix.tsv;
• release/compiler-memory-heavy-gates.tsv;
• release/compiler-memory-limitations.tsv;
• release/compiler-memory-release-diagnostics-report.tsv;
• perf/compiler-memory-release-budgets.tsv;
• compat/compiler-memory-release-contract.tsv.

release/compiler-memory-release-decision.tsv is the release decision row. It

cannot pass unless the final gate rows, public support matrix, artifact

manifest, heavy-gate plan, limitations, docs, and `make

compiler-memory-release-check` all line up.

Support Status

The public support matrix uses four statuses:

• implemented: the surface has implementation, tests, docs, and release

evidence for the named scope.

• target-gated: the surface is real, but only for targets or profiles that

have evidence.

• deferred: the surface is not a release closure claim.
• research-only: the surface exists only as a measured research or discovery

lane and does not change default compiler behavior.

This release integration gate marks general cross-toolchain CAS as deferred.

Query-engine caching and native compile-cache evidence are indexed, but a

release cannot claim full artifact CAS until the deferred CAS work is

implemented and this support row changes with evidence.

Artifact Manifest

compiler-memory-release/artifact-manifest.tsv and

release/compiler-memory-release-artifacts.tsv require release artifacts for:

• cache schemas;
• profile artifacts;
• order files;
• allocator reports;
• validation reports;
• benchmark results;
• rollback controls.

The checker verifies that every artifact path exists, has a sha256: hash

marker, and is tied to a bounded gate.

Developer And Operator Use

Use the fastest bounded gate that matches the work:

• Fast development builds: make compiler-query-engine-check.
• Optimized AOT profile work: make pgo-thin-summary-check.
• Post-link layout work: make post-link-layout-check.
• Runtime allocation and memory semantics work:

make allocator-fast-path-check and

make memory-semantics-decision-check.

• Hosted JIT work: make copy-patch-jit-check.
• ML research changes: make ml-heuristics-research-check.
• EqSat research changes: make eqsat-superoptimization-check.
• Release integration: make compiler-memory-release-check.

Heavy gates are explicit release operations. Run

make native-performance-release-check, make release-verify,

make selfhost-guard, and make final-release-discipline-check only when you

intend to evaluate a release candidate.

Limitations

The current release integration evidence documents these limits:

• full cross-toolchain CAS is deferred;
• ML and EqSat lanes are non-default unless promoted through deterministic

compiler implementation;

• PGO and post-link layout are target-gated;
• copy-and-patch JIT is hosted-target gated;
• heavy release gates are explicit operations, not default development checks.

These limits are part of release evidence in

compiler-memory-release/limitations.tsv and

release/compiler-memory-limitations.tsv.

Failure Policy

make compiler-memory-release-check fails closed on:

• missing artifact categories or missing artifact paths;
• unknown support statuses;
• heavy gates marked as default development operations;
• deferred, target-gated, or research-only rows without limitations;
• release decision rows without support, artifact, heavy-gate, limitation, and

docs evidence;

• missing public documentation.