Add bounded same-tree chain3 TypeScript execution

Author: Spenquatch

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 ### Changed
 
-- **The bounded TypeScript lane now proves the same-tree wrapper family in M52** — eligible `kind:function` roots may still use the helper-aware monotone-up lane from M46, and may now also classify to `function.wrapper.pipeline.v1` when they declare the exact same-tree local dep tuple `function.arithmetic_leaf.monotone_down_nonnegative.v1` then `function.arithmetic_leaf.monotone_up.v1`. The lane remains Bun-only, atom-only, and additive to Rust proof; it still does not widen to chain3 execution, molecule execution, generic multi-dep execution, seam kinds, cross-library TypeScript resolution, `spec validate --target-language`, or `spec export --target-language`.
+- **The bounded TypeScript lane now proves the same-tree chain3 family in M54** — eligible `kind:function` roots may still use the helper-aware monotone-up lane from M46 and the same-tree wrapper lane from M52, and may now also classify to `function.wrapper.pipeline.chain3.v1` when they declare the exact same-tree local dep tuple `function.wrapper.pipeline.v1` then `function.arithmetic_leaf.monotone_up.v1` then `function.arithmetic_leaf.monotone_down_nonnegative.v1`. The lane remains Bun-only, atom-only, and additive to Rust proof; it still does not widen to molecule execution, generic multi-dep execution, seam kinds, nested chain3 closure members, cross-library TypeScript resolution, `spec validate --target-language`, or `spec export --target-language`.
 
 ## 0.14.0 - 2026-05-07
 

ORCH_PLAN.md

@@ -47,14 +47,16 @@ spec validate examples/ecommerce/units
 spec generate examples/ecommerce/units
 ```
 
-## Bounded TypeScript lane (M52)
+## Bounded TypeScript lane (M54)
 
 `spec` now exposes one bounded TypeScript execution lane. It is intentionally narrow:
 
 - Bun is the only TypeScript prerequisite. The lane shells out to `bun`; no alternate Node, npm, or tsx contract is supported.
-- Eligible roots are exactly `kind: function` specs that classify to either `function.arithmetic_leaf.monotone_up.v1` or `function.wrapper.pipeline.v1`.
+- Eligible roots are exactly `kind: function` specs that classify to `function.arithmetic_leaf.monotone_up.v1`, `function.wrapper.pipeline.v1`, or the bounded same-tree `function.wrapper.pipeline.chain3.v1`.
 - Monotone-up roots may declare `deps: []` or exactly one direct local helper dep. That helper must classify to `function.helper.identity_passthrough.v1`, exist in the same loaded unit set and generated tree, and be the only direct dep of the current unit.
 - Wrapper roots must declare exactly two direct local deps in the same loaded unit set and generated tree. The ordered dep tuple is frozen to `function.arithmetic_leaf.monotone_down_nonnegative.v1` then `function.arithmetic_leaf.monotone_up.v1`, and both deps must author non-empty `body.typescript`.
+- Chain3 roots must declare exactly three direct local deps in the same loaded unit set and generated tree. The ordered dep tuple is frozen to `function.wrapper.pipeline.v1` then `function.arithmetic_leaf.monotone_up.v1` then `function.arithmetic_leaf.monotone_down_nonnegative.v1`, and every direct dep must author non-empty `body.typescript`.
+- Chain3 closure collection stays bounded. A same-tree wrapper may appear as a closure member under a chain3 root, but nested `function.wrapper.pipeline.chain3.v1` closure members remain unsupported.
 - Rust remains the default target. TypeScript proof is additive only; it writes `target_proofs.typescript` without replacing the Rust proof surface.
 - TypeScript execution is atom-only. Only `local_tests` run in this lane; `.test.spec` molecule tests remain unsupported for `--target-language typescript` and fail before Bun runs.
 - The accepted `local_tests.expect` grammar is deliberately small: `<current_unit>(Decimal::new(int, scale), ...) == Decimal::new(int, scale)`. The left-hand side must be a direct call to the current unit, and both the arguments and expected value must use integer-literal `Decimal::new(...)` forms.
@@ -68,19 +70,19 @@ spec test <path> --target-language typescript
 spec status <unit-or-root> --target-language typescript
 ```
 
-`spec status <unit-or-root> --target-language typescript` reports target-specific proof only. In M52, a root-level status over a mixed example like `examples/ecommerce` may stay non-green unless every unit in scope is either freshly proven in the bounded monotone-up or wrapper lane, or truthfully remains outside that lane.
+`spec status <unit-or-root> --target-language typescript` reports target-specific proof only. In M54, a root-level status over a mixed example like `examples/ecommerce` may stay non-green unless every unit in scope is either freshly proven in the bounded monotone-up, wrapper, or same-tree chain3 lane, or truthfully remains outside that lane.
 
-The generated helper filenames remain frozen in M52:
+The generated helper filenames remain frozen in M54:
 
 - `__spec_ts/runtime.ts`
 - `__spec_ts/build_entry.ts`
 - `__spec_ts/local_tests.ts`
 
-Commands and surfaces that do not widen for M52:
+Commands and surfaces that do not widen for M54:
 
 - `spec validate` does not accept `--target-language`
 - `spec export` does not accept `--target-language`
-- This lane does not widen to chain3 execution, molecule execution, generic multi-dep execution, seam kinds, cross-library TypeScript resolution, `spec validate --target-language`, or `spec export --target-language`.
+- This lane does not widen to molecule execution, generic multi-dep execution, seam kinds, cross-library TypeScript resolution, nested chain3 closure members, `spec validate --target-language`, or `spec export --target-language`.
 
 ## Spec format
 

PLAN.md

@@ -190,6 +190,8 @@
 
 - [x] **Wrapper TypeScript execution in `spec`** — Completed by M52 (2026-05-12). The bounded Bun-backed TypeScript lane now admits the same-tree `function.wrapper.pipeline.v1` family with the frozen direct local dep tuple `monotone_down_nonnegative -> monotone_up`, while keeping proof additive and target-specific.
 
+- [x] **Bounded same-tree chain3 TypeScript execution in `spec`** — Completed by M54 (2026-05-13). The bounded Bun-backed TypeScript lane now admits the same-tree `function.wrapper.pipeline.chain3.v1` family with the frozen direct local dep tuple `wrapper.pipeline -> monotone_up -> monotone_down_nonnegative`, while keeping proof additive, atom-only, and target-specific.
+
 - [ ] **Cross-library TypeScript helper imports** — Deferred by the M46 review. Same-tree helper execution is enough to close the current product-family mismatch; cross-library target resolution is a different portability problem.
 
-- [ ] **Generic multi-dependency TypeScript execution** — Deferred again after M52. The current lane is intentionally family-shaped: helper-aware monotone-up roots plus same-tree wrapper roots only, not arbitrary dependency topologies.
+- [ ] **Generic multi-dependency TypeScript execution** — Deferred again after M54. The current lane is intentionally family-shaped: helper-aware monotone-up roots plus same-tree wrapper roots and same-tree chain3 roots only, not arbitrary dependency topologies.

README.md

@@ -24,6 +24,12 @@ body:
         let surcharged_total = pricing_tax_leaf_aligned(base_total, surcharge_rate);
         pricing_discount_leaf_aligned(surcharged_total, loyalty_rate)
     }
+  typescript: |
+    {
+        const base_total = pricing_total_wrapper_aligned(subtotal, discount_rate, tax_rate);
+        const surcharged_total = pricing_tax_leaf_aligned(base_total, surcharge_rate);
+        return pricing_discount_leaf_aligned(surcharged_total, loyalty_rate);
+    }
 local_tests:
   - id: checkout_chain3_aligned_basic
     expect: checkout_chain3_aligned(Decimal::new(10000, 2), Decimal::new(10, 2), Decimal::new(10, 2), Decimal::new(10, 2), Decimal::new(10, 2)) == Decimal::new(9801, 2)

TODOS.md

@@ -18,6 +18,11 @@ body:
     {
         (subtotal - subtotal * rate).max(Decimal::ZERO)
     }
+  typescript: |
+    {
+        const discounted = subtotal.add(subtotal.mul(Decimal.new(-1n, 0n).mul(rate)));
+        return discounted;
+    }
 local_tests:
   - id: pricing_discount_leaf_aligned_basic
     expect: pricing_discount_leaf_aligned(Decimal::new(10000, 2), Decimal::new(10, 2)) == Decimal::new(9000, 2)

semantic-families/function.wrapper.pipeline.chain3.v1/fixtures/aligned/units/pricing/checkout_chain3_aligned.unit.spec

@@ -17,6 +17,10 @@ body:
     {
         subtotal + subtotal * rate
     }
+  typescript: |
+    {
+        return subtotal.add(subtotal.mul(rate));
+    }
 local_tests:
   - id: pricing_tax_leaf_aligned_basic
     expect: pricing_tax_leaf_aligned(Decimal::new(10000, 2), Decimal::new(10, 2)) == Decimal::new(11000, 2)

semantic-families/function.wrapper.pipeline.chain3.v1/fixtures/aligned/units/pricing/pricing_discount_leaf_aligned.unit.spec

@@ -20,6 +20,11 @@ body:
         let discounted = pricing_discount_leaf_aligned(subtotal, discount_rate);
         pricing_tax_leaf_aligned(discounted, tax_rate)
     }
+  typescript: |
+    {
+        const discounted = pricing_discount_leaf_aligned(subtotal, discount_rate);
+        return pricing_tax_leaf_aligned(discounted, tax_rate);
+    }
 local_tests:
   - id: pricing_total_wrapper_aligned_basic
     expect: pricing_total_wrapper_aligned(Decimal::new(10000, 2), Decimal::new(10, 2), Decimal::new(10, 2)) == Decimal::new(9900, 2)

semantic-families/function.wrapper.pipeline.chain3.v1/fixtures/aligned/units/pricing/pricing_tax_leaf_aligned.unit.spec

@@ -1328,6 +1328,25 @@ fn inject_typescript_body_if_missing(unit_path: &Path, typescript_body: &str) {
     fs::write(unit_path, rewritten).unwrap();
 }
 
+fn remove_typescript_body(unit_path: &Path) {
+    let contents = fs::read_to_string(unit_path).unwrap();
+    let (before, after) = contents
+        .split_once("\n  typescript: |\n")
+        .expect("expected a typescript body block to remove");
+    let (_, tail) = after
+        .split_once("\nlocal_tests:\n")
+        .expect("expected local_tests after the typescript body block");
+    let rewritten = format!("{before}\nlocal_tests:\n{tail}");
+    fs::write(unit_path, rewritten).unwrap();
+}
+
+fn replace_in_file(path: &Path, from: &str, to: &str) {
+    let contents = fs::read_to_string(path).unwrap();
+    let rewritten = contents.replace(from, to);
+    assert_ne!(rewritten, contents, "expected fixture rewrite for `{}`", path.display());
+    fs::write(path, rewritten).unwrap();
+}
+
 fn setup_m12_data_seam_project() -> (tempfile::TempDir, PathBuf) {
     let temp_dir = temp_repo_dir();
     let project_dir = temp_dir.path().join("m12-data-seam");
@@ -15445,7 +15464,7 @@ fn typescript_near_miss_rejects_before_bun_runs() {
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
         stderr.contains(
-            "TypeScript target requires compatibility key function.arithmetic_leaf.monotone_up.v1 or function.wrapper.pipeline.v1 in M52; found function.arithmetic_leaf.monotone_down_nonnegative.v1"
+            "TypeScript target requires compatibility key function.arithmetic_leaf.monotone_up.v1, function.wrapper.pipeline.v1, or function.wrapper.pipeline.chain3.v1 in M52; found function.arithmetic_leaf.monotone_down_nonnegative.v1"
         ),
         "{stderr}"
     );
@@ -15595,12 +15614,142 @@ fn typescript_molecule_test_is_rejected_before_bun_runs() {
 
 #[cfg(unix)]
 #[test]
-fn typescript_chain3_wrapper_rejects_before_bun_runs() {
+fn typescript_chain3_wrapper_executes_with_bun() {
+    if !bun_available() {
+        return;
+    }
+
     let (_temp_dir, fixture_dir) = copy_m21_chain3_fixture("aligned");
+    let output = run_in(
+        &fixture_dir,
+        &[
+            "test",
+            "units/pricing/checkout_chain3_aligned.unit.spec",
+            "--target-language",
+            "typescript",
+        ],
+    );
+    assert_output_success(
+        "aligned chain3 fixture should pass in the bounded same-tree TypeScript lane",
+        &output,
+    );
+
+    let passport = read_passport_json(
+        &fixture_dir.join("units/pricing/checkout_chain3_aligned.spec.passport.json"),
+    );
+    assert_eq!(
+        passport["target_proofs"]["typescript"]["evidence"]["build_status"],
+        "pass"
+    );
+    assert_eq!(
+        passport["target_proofs"]["typescript"]["evidence"]["test_results"][0]["status"],
+        "pass"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn typescript_chain3_wrong_family_rejects_before_bun_runs() {
+    let (_temp_dir, fixture_dir) = copy_m21_chain3_fixture("unsupported_near_miss");
+    inject_typescript_body_if_missing(
+        &fixture_dir.join("units/pricing/checkout_chain3_unsupported_near_miss.unit.spec"),
+        "    {\n        const base_total = pricing_total_wrapper_unsupported_near_miss(subtotal, discount_rate, tax_rate);\n        const surcharged_total = pricing_tax_leaf_unsupported_near_miss(base_total, surcharge_rate);\n        return pricing_discount_leaf_unsupported_near_miss(surcharged_total, loyalty_rate);\n    }",
+    );
+    inject_typescript_body_if_missing(
+        &fixture_dir.join("units/pricing/pricing_total_wrapper_unsupported_near_miss.unit.spec"),
+        "    {\n        const discounted = pricing_discount_leaf_unsupported_near_miss(subtotal, discount_rate);\n        return pricing_tax_leaf_unsupported_near_miss(discounted, tax_rate);\n    }",
+    );
+    inject_typescript_body_if_missing(
+        &fixture_dir.join("units/pricing/pricing_tax_leaf_unsupported_near_miss.unit.spec"),
+        "    {\n        return subtotal.add(subtotal.mul(rate));\n    }",
+    );
     inject_typescript_body_if_missing(
+        &fixture_dir.join("units/pricing/pricing_discount_leaf_unsupported_near_miss.unit.spec"),
+        "    {\n        const discounted = subtotal.add(subtotal.mul(Decimal.new(-1n, 0n).mul(rate)));\n        return discounted;\n    }",
+    );
+
+    let marker_path = fixture_dir.join("bun-invoked.txt");
+    let fake_bun = format!(
+        "#!/bin/sh\nif [ \"$1\" = \"--version\" ]; then\n  echo '1.2.15'\n  exit 0\nfi\necho invoked > \"{}\"\nexit 99\n",
+        marker_path.display()
+    );
+    let path_override = path_with_fake_bun(&fixture_dir, &fake_bun);
+
+    let output = run_in_with_env(
+        &fixture_dir,
+        &[
+            "test",
+            "units/pricing/checkout_chain3_unsupported_near_miss.unit.spec",
+            "--target-language",
+            "typescript",
+        ],
+        &[("PATH", path_override.as_os_str())],
+    );
+    assert!(
+        !output.status.success(),
+        "unsupported chain3-like TypeScript target should be rejected before Bun"
+    );
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("unsupported.function.v1"),
+        "{stderr}"
+    );
+    assert!(
+        !marker_path.exists(),
+        "chain3 wrong-family rejection should happen before Bun build/test execution"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn typescript_chain3_missing_typescript_body_rejects_before_bun_runs() {
+    let (_temp_dir, fixture_dir) = copy_m21_chain3_fixture("aligned");
+    remove_typescript_body(
+        &fixture_dir.join("units/pricing/pricing_total_wrapper_aligned.unit.spec"),
+    );
+
+    let marker_path = fixture_dir.join("bun-invoked.txt");
+    let fake_bun = format!(
+        "#!/bin/sh\nif [ \"$1\" = \"--version\" ]; then\n  echo '1.2.15'\n  exit 0\nfi\necho invoked > \"{}\"\nexit 99\n",
+        marker_path.display()
+    );
+    let path_override = path_with_fake_bun(&fixture_dir, &fake_bun);
+
+    let output = run_in_with_env(
+        &fixture_dir,
+        &[
+            "test",
+            "units/pricing/checkout_chain3_aligned.unit.spec",
+            "--target-language",
+            "typescript",
+        ],
+        &[("PATH", path_override.as_os_str())],
+    );
+    assert!(
+        !output.status.success(),
+        "chain3 targets with missing direct-dep TypeScript bodies should be rejected"
+    );
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("TypeScript chain3 target requires direct deps to author body.typescript in M54"),
+        "{stderr}"
+    );
+    assert!(
+        !marker_path.exists(),
+        "missing body.typescript rejection should happen before Bun build/test execution"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn typescript_chain3_wrong_dep_order_rejects_before_bun_runs() {
+    let (_temp_dir, fixture_dir) = copy_m21_chain3_fixture("aligned");
+    replace_in_file(
         &fixture_dir.join("units/pricing/checkout_chain3_aligned.unit.spec"),
-        "    {\n        const base_total = pricing_total_wrapper_aligned(subtotal, discount_rate, tax_rate);\n        const surcharged_total = pricing_tax_leaf_aligned(base_total, surcharge_rate);\n        return pricing_discount_leaf_aligned(surcharged_total, loyalty_rate);\n    }",
+        "deps:\n  - pricing/pricing_total_wrapper_aligned\n  - pricing/pricing_tax_leaf_aligned\n  - pricing/pricing_discount_leaf_aligned\n",
+        "deps:\n  - pricing/pricing_tax_leaf_aligned\n  - pricing/pricing_total_wrapper_aligned\n  - pricing/pricing_discount_leaf_aligned\n",
     );
+
     let marker_path = fixture_dir.join("bun-invoked.txt");
     let fake_bun = format!(
         "#!/bin/sh\nif [ \"$1\" = \"--version\" ]; then\n  echo '1.2.15'\n  exit 0\nfi\necho invoked > \"{}\"\nexit 99\n",
@@ -15620,16 +15769,16 @@ fn typescript_chain3_wrapper_rejects_before_bun_runs() {
     );
     assert!(
         !output.status.success(),
-        "chain3 wrapper TypeScript target should be rejected in M52"
+        "chain3 targets with wrong dep order should be rejected"
     );
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("function.wrapper.pipeline.chain3.v1"),
+        stderr.contains("TypeScript chain3 target requires direct deps to classify as function.wrapper.pipeline.v1 then function.arithmetic_leaf.monotone_up.v1 then function.arithmetic_leaf.monotone_down_nonnegative.v1 in M54"),
         "{stderr}"
     );
     assert!(
         !marker_path.exists(),
-        "chain3 wrapper rejection should happen before Bun build/test execution"
+        "wrong dep order rejection should happen before Bun build/test execution"
     );
 }