fix(runtime): clean up test helper allocations

.outline/sdd/task-10-report.md

@@ -0,0 +1,126 @@
+# Task 10 audit fix report
+
+Status: DONE
+
+## Verdict
+
+`raise_type_error` is now total: it always loads a fresh known non-callable
+(`Constant::Boolean(true)`) and issues a bare `Call`, never invoking a
+user-returned value. Callable invalid auto-accessor decorator returns TypeError
+in Interpreter/JIT/AOT with side-effect count zero, matching TypeScript+Node.
+
+## Brief (authoritative)
+
+`.outline/sdd/task-10-brief.md` Audit fix:
+
+- Remove the offender parameter from `raise_type_error`.
+- Helper loads a fresh known non-callable constant and issues the bare Call.
+- Update every call site.
+- Add `invalid_auto_accessor_decorator_return_matches_tsc_oracle_in_every_execution_mode`.
+- Commit: `fix(compiler): make bare TypeError throws total`.
+
+## Gap
+
+`apply_auto_accessor_decorators` rejected non-object decorator returns by
+passing the returned value to `raise_type_error`. When that return was a
+function, the helper `Call`ed it, running user code instead of throwing an
+engine-origin TypeError.
+
+## Production fix
+
+File: `crates/bamts-compiler/src/lower.rs`
+
+```rust
+fn raise_type_error(
+    &mut self,
+    builder: &mut ModuleBuilder,
+    range: TextRange,
+) -> Result<(), LowerError> {
+    // Always call a fresh known non-callable. Never pass a user-returned
+    // value here: a callable invalid decorator return would run user code
+    // instead of throwing an engine TypeError.
+    let dummy = self.load_constant(builder, Constant::Boolean(true), range)?;
+    let undefined = self.undefined(builder, range)?;
+    let _ = self.call_with_registers(range, dummy, undefined, &[])?;
+    Ok(())
+}
+```
+
+Updated call sites (5):
+
+- `accept_replacement_callable` — drop `returned`
+- `collect_optional_callable` — drop `returned`
+- closed `addInitializer` arm — drop redundant `closed_dummy` load; helper owns it
+- open `addInitializer` bad-callback arm — drop `callback`
+- `apply_auto_accessor_decorators` — drop `returned` (the audit hole)
+
+Instruction shape unchanged: still bare `Call` of a non-callable, no
+`LoadGlobal("TypeError")`, no `Construct`, no `Throw`.
+
+## New differential
+
+`invalid_auto_accessor_decorator_return_matches_tsc_oracle_in_every_execution_mode`
+in `crates/bamts-verification/tests/corpus_differential.rs`:
+
+- Auto-accessor decorator returns a function that increments `sideEffects` if
+  invoked.
+- TypeScript+Node and BamTS Interpreter/JIT/AOT catch `TypeError`.
+- Observable output includes `sideEffects:0` (returned callable never invoked).
+
+## Focused verification (exact evidence)
+
+Instruction-shape:
+
+```bash
+cargo test -p bamts-compiler --lib raise_type_error
+cargo test -p bamts-compiler --lib escaped_add_initializer_after_close_takes_type_error_path_not_append
+```
+
+```text
+test lower::tests::raise_type_error_is_a_bare_throw_without_constructor_lookup ... ok
+test result: ok. 1 passed; 0 failed; … 507 filtered out
+
+test lower::tests::escaped_add_initializer_after_close_takes_type_error_path_not_append ... ok
+test result: ok. 1 passed; 0 failed; … 507 filtered out
+```
+
+Named differentials (all-mode oracle):
+
+```bash
+cargo test -p bamts-verification --test corpus_differential \
+  invalid_class_decorator_return_matches_tsc_oracle_in_every_execution_mode -- --exact
+cargo test -p bamts-verification --test corpus_differential \
+  invalid_auto_accessor_decorator_return_matches_tsc_oracle_in_every_execution_mode -- --exact
+```
+
+```text
+test invalid_class_decorator_return_matches_tsc_oracle_in_every_execution_mode ... ok
+test result: ok. 1 passed; 0 failed; … 45 filtered out
+
+test invalid_auto_accessor_decorator_return_matches_tsc_oracle_in_every_execution_mode ... ok
+test result: ok. 1 passed; 0 failed; … 45 filtered out
+```
+
+## Contract map
+
+| Contract | Evidence | Status |
+|---|---|---|
+| `raise_type_error` loads internal non-callable and bare-Calls it — no offender param | `lower.rs` helper + call sites | PASS |
+| Instruction shape still bare Call / no TypeError global / no Construct / no Throw | `raise_type_error_is_a_bare_throw_without_constructor_lookup` | PASS |
+| Closed `addInitializer` still takes type-error path | `escaped_add_initializer_after_close_takes_type_error_path_not_append` | PASS |
+| Invalid class decorator return still matches tsc/Node in every mode | `invalid_class_decorator_return_matches_tsc_oracle_in_every_execution_mode` | PASS |
+| Callable invalid auto-accessor return TypeErrors; side effect count stays 0 | `invalid_auto_accessor_decorator_return_matches_tsc_oracle_in_every_execution_mode` | PASS |
+
+## Scope boundaries
+
+- Staged only `lower.rs`, the new differential, and this report.
+- Other dirty tree work left unstaged.
+- Native materialization remains Task 11.
+
+## Commit
+
+- Message: `fix(compiler): make bare TypeError throws total`
+
+## Result
+
+DONE.

.outline/sdd/task-14-report.md

@@ -0,0 +1,97 @@
+# Task 14 implementer report
+
+Status: DONE
+
+## Verdict
+
+High-severity Promise rejection materialization defect is fixed at the single
+`reject_promise` sink. Lazy engine-origin reasons (`UNDEFINED` + non-Bytecode
+origin) materialize once into realm-intrinsic Errors before settlement;
+already-materialized and Bytecode-origin reasons retain identity. Async
+function, async generator body, incompatible receiver, failed import, and
+direct sink identity/materialization tests are green.
+
+## Blocking finding (resolved)
+
+Engine-origin Promise rejections outside `settle_async_step` previously stored
+`Value::UNDEFINED` with a non-Bytecode origin, so JavaScript handlers observed
+`undefined` instead of an intrinsic Error. Paths affected:
+
+- async generator body throws (`settle_async_generator_step` Throw arm)
+- `AsyncGenerator.prototype.next` incompatible receiver
+- failed-import / dynamic-import rejection forwarding
+- any reaction that forwarded a still-lazy reason through `reject_promise`
+
+## Production fix
+
+`Machine::reject_promise` in `crates/bamts-runtime/src/lib.rs`:
+
+- when `catch_value_needs_materialization(reason, origin)` holds and the
+  promise is still pending, replace `reason` with
+  `self.materialize_engine_origin(origin)?` before `settle_promise`
+- already-settled promises remain no-ops and do not allocate a reason
+- non-lazy / Bytecode reasons pass through unchanged
+
+No call-site fan-out: async generators, incompatible receivers, import
+replay, and reaction forwarding all inherit the sink contract. Existing
+`settle_async_step` normalization remains harmless (post-materialize reasons
+are non-`UNDEFINED`, so no double allocation).
+
+## Tests
+
+Added/strengthened in `crates/bamts-runtime/src/lib.rs`:
+
+- `reject_promise_materializes_lazy_type_error_once` — direct sink; lazy
+  TypeError materializes once; second reject on settled promise is a no-op
+- `reject_promise_keeps_prematerialized_identity` — direct sink; concrete
+  Bytecode reason keeps exact Value identity
+- `async_generator_engine_type_error_rejection_has_intrinsic_shape` — body
+  calls a non-callable; front `next()` capability rejects with intrinsic
+  TypeError
+- `async_generator_next_on_incompatible_receiver_rejects_promise` —
+  strengthened from asserting `UNDEFINED` to asserting TypeError
+  name/message/`instanceof` and matching origin
+
+Existing green:
+
+- `async_engine_type_error_rejection_has_intrinsic_shape`
+- `async_prematerialized_rejection_keeps_identity`
+- `failed_import_caught_by_dependent_is_intrinsic_type_error`
+- `dynamic_import_rethrows_one_stored_failure_at_each_import_site`
+
+## Verification
+
+```bash
+cargo test -p bamts-runtime --lib reject_promise_
+cargo test -p bamts-runtime --lib async_engine_type_error_rejection_has_intrinsic_shape
+cargo test -p bamts-runtime --lib async_prematerialized_rejection_keeps_identity
+cargo test -p bamts-runtime --lib async_generator_engine_type_error_rejection_has_intrinsic_shape
+cargo test -p bamts-runtime --lib async_generator_next_on_incompatible_receiver_rejects_promise
+cargo test -p bamts-runtime --lib failed_import_caught_by_dependent_is_intrinsic_type_error
+cargo test -p bamts-runtime --lib dynamic_import_rethrows_one_stored_failure_at_each_import_site
+```
+
+All listed filters: passed (0 failed).
+
+Neighbors also green: `async_generator_throw_rejects_front_and_drains_queue`,
+`async_generator_returned_promise_rejection_rejects_front`.
+
+## Staging discipline
+
+- Staged only `crates/bamts-runtime/src/lib.rs` and this report
+  (force-added under ignored `.outline/sdd/`).
+- Left unrelated dirty workspace files unstaged.
+
+## Commit
+
+- Message: `fix(runtime): materialize promise rejection reasons`
+- High-severity findings remaining for Task 14 architecture brief: **0**
+  (this blocking finding closed; medium/low from oracle/reviewer left for
+  the final findings task).
+
+## Self-review
+
+- Single sink; no duplicated normalizers at each call site.
+- Pending-check before materialization avoids heap churn on settled no-ops.
+- Identity contracts for prematerialized / Bytecode reasons preserved.
+- Prior Task 9 async-function path remains green without edits.

.outline/sdd/task-7-fix-report.md

@@ -0,0 +1,84 @@
+# Task 7 audit fix report
+
+Status: DONE (test-only)
+
+## Verdict
+
+Added `construct_value_preserves_engine_throw_origin`. Focused suite is 4/4 green.
+No production edit.
+
+## Gap
+
+`nested_callback_construct_engine_type_error_is_intrinsic` raises a `construct`
+TypeError inside an `Array.prototype.map` callback, so the throw crosses
+`call_value`, not the runtime-constructor boundary in `construct_value`.
+`construct_value`'s own `UncaughtThrow → ThrowValueOrigin` conversion was
+therefore uncovered.
+
+## Contract restored
+
+File: `crates/bamts-runtime/src/lib.rs`
+
+- `construct_value` maps `RuntimeErrorKind::UncaughtThrow { value, origin }` to
+  `EvalFailure::ThrowValueOrigin { value, origin }` (approx. lines 6724–6730).
+- New unit obtains a runtime closure constructor, drives
+  `Machine::construct_value` directly, and asserts payload + origin exactly.
+
+## New test
+
+`tests::construct_value_preserves_engine_throw_origin`
+
+- Allocates a runtime `HeapEntry::Function` whose body `Call`s non-callable
+  `Int32(0)`, producing engine `ThrowOrigin::TypeError { operation: "call" }`.
+- Invokes `machine.construct_value(callee, &[])`.
+- Asserts:
+
+```rust
+Err(EvalFailure::ThrowValueOrigin {
+    value: Value::UNDEFINED,
+    origin: ThrowOrigin::TypeError { operation: "call" },
+})
+```
+
+- `operation: "call"` is deliberate: the outer boundary is construct, so a
+  leaked boundary error would read `"construct"`. Also asserts
+  `machine.frames.is_empty()`.
+
+## Focused verification
+
+Command:
+
+```bash
+cargo test -p bamts-runtime --lib -- \
+  native_callback_throw_is_caught_at_outer_call_site \
+  nested_callback_call_engine_type_error_is_intrinsic \
+  nested_callback_construct_engine_type_error_is_intrinsic \
+  construct_value_preserves_engine_throw_origin
+```
+
+Result:
+
+```text
+running 4 tests
+test tests::construct_value_preserves_engine_throw_origin ... ok
+test tests::native_callback_throw_is_caught_at_outer_call_site ... ok
+test tests::nested_callback_construct_engine_type_error_is_intrinsic ... ok
+test tests::nested_callback_call_engine_type_error_is_intrinsic ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 429 filtered out; finished in 0.01s
+```
+
+| Concern | Test | Result |
+|---|---|---|
+| Nested call engine TypeError | `nested_callback_call_engine_type_error_is_intrinsic` | ok |
+| Nested construct engine TypeError | `nested_callback_construct_engine_type_error_is_intrinsic` | ok |
+| Explicit thrown-value callback | `native_callback_throw_is_caught_at_outer_call_site` | ok |
+| Direct `construct_value` origin | `construct_value_preserves_engine_throw_origin` | ok |
+
+## Scope
+
+- Test-only addition in `mod tests`.
+- Existing outer-catch tests kept unchanged.
+- No production edit.
+- Logical diff is the new unit only (inserted after
+  `nested_callback_construct_engine_type_error_is_intrinsic`).