feat: macros (multi-rep, hygiene), Drop field-move, lean multi-OS CI

Sessions 56–69: declarative macro! with rep/zip/literal/block and unhygienic var $name binders; partial field-move skip Drop; @[Release] polish; LSP type hierarchy; CI Nim cache + lean macOS + Windows smoke.
2026-07-20 17:19:46 +03:00
parent 6f2a3b1d88
commit fe3b1e8b6a
41 changed files with 5281 additions and 141 deletions
@@ -1,4 +1,6 @@
-# Default PR / main CI: full `make test` (not selfhost fixed-point — see selfhost-loop.yml).
+# Default PR / main CI: split Linux jobs + lean macOS + Windows bootstrap smoke.
 # Full sequential suite locally: `make test`.
 # Selfhost fixed-point: see selfhost-loop.yml (not on every PR).
 name: ci
 on:
@@ -11,42 +13,403 @@ concurrency:
  group: ci-${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
 env:
  # Pin patch for stable toolchain cache keys (was 2.0.x).
  NIM_VERSION: "2.0.8"
  # setup-nim-action install dir (relative to workspace)
  NIM_INSTALL_DIR: ".nim_runtime"
 jobs:
-  test:
+  # ── Shared bootstrap build (Linux) ──────────────────────────────────────
-    name: make test
+  build:
    name: build (ubuntu)
    runs-on: ubuntu-latest
-    timeout-minutes: 90
+    timeout-minutes: 20
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Cache Nim toolchain
        id: cache-nim
        uses: actions/cache@v4
        with:
          path: ${{ env.NIM_INSTALL_DIR }}
          key: ${{ runner.os }}-nim-${{ env.NIM_VERSION }}-v1
      - name: Install Nim
        if: steps.cache-nim.outputs.cache-hit != 'true'
        uses: jiro4989/setup-nim-action@v2
        with:
-          nim-version: "2.0.x"
+          nim-version: ${{ env.NIM_VERSION }}
          nim-install-directory: ${{ env.NIM_INSTALL_DIR }}
          repo-token: ${{ secrets.GITHUB_TOKEN }}
      - name: PATH for cached Nim
        if: steps.cache-nim.outputs.cache-hit == 'true'
        run: |
          echo "$PWD/${{ env.NIM_INSTALL_DIR }}/bin" >> "$GITHUB_PATH"
          echo "$HOME/.nimble/bin" >> "$GITHUB_PATH"
      - name: Cache nimcache (bootstrap)
        uses: actions/cache@v4
        with:
          path: nimcache
          key: ${{ runner.os }}-nimcache-build-${{ hashFiles('bootstrap/**/*.nim') }}-v1
          restore-keys: |
            ${{ runner.os }}-nimcache-build-
      - name: Install build deps
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends \
            gcc make binutils libssl-dev python3
-      - name: Bootstrap + full test suite
+      - name: Build buxc
        run: |
          nim -v
          make build
      - name: Upload buxc
        uses: actions/upload-artifact@v4
        with:
          name: buxc-linux
          path: buxc
          retention-days: 3
  # ── Parallel Linux suites (reuse prebuilt buxc) ─────────────────────────
  unit:
    name: unit + fmt
    needs: build
    runs-on: ubuntu-latest
    timeout-minutes: 25
    steps:
      - uses: actions/checkout@v4
      - name: Cache Nim toolchain
        id: cache-nim
        uses: actions/cache@v4
        with:
          path: ${{ env.NIM_INSTALL_DIR }}
          key: ${{ runner.os }}-nim-${{ env.NIM_VERSION }}-v1
      - name: Install Nim
        if: steps.cache-nim.outputs.cache-hit != 'true'
        uses: jiro4989/setup-nim-action@v2
        with:
          nim-version: ${{ env.NIM_VERSION }}
          nim-install-directory: ${{ env.NIM_INSTALL_DIR }}
          repo-token: ${{ secrets.GITHUB_TOKEN }}
      - name: PATH for cached Nim
        if: steps.cache-nim.outputs.cache-hit == 'true'
        run: |
          echo "$PWD/${{ env.NIM_INSTALL_DIR }}/bin" >> "$GITHUB_PATH"
          echo "$HOME/.nimble/bin" >> "$GITHUB_PATH"
      - name: Cache nimcache (unit tests)
        uses: actions/cache@v4
        with:
          path: nimcache
          key: ${{ runner.os }}-nimcache-unit-${{ hashFiles('bootstrap/**/*.nim', 'tests/**/*.nim') }}-v1
          restore-keys: |
            ${{ runner.os }}-nimcache-unit-
            ${{ runner.os }}-nimcache-build-
      - name: Install build deps
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends gcc make libssl-dev
      - name: Download buxc
        uses: actions/download-artifact@v4
        with:
          name: buxc-linux
      - name: Prepare buxc
        run: chmod +x buxc && ./buxc --version
      - name: fmt-check + unit tests
        env:
-          # Ensure registry / selfhost smokes see a clean env
+          BUX_SKIP_BUILD: "1"
-          BUX_NO_LINE: ""
+        run: |
          unset BUX_DEBUG_FILE || true
          make fmt-check BUX_SKIP_BUILD=1
          make test-unit BUX_SKIP_BUILD=1
  examples:
    name: examples
    needs: build
    runs-on: ubuntu-latest
    timeout-minutes: 40
    steps:
      - uses: actions/checkout@v4
      - name: Install build deps
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends gcc make libssl-dev
      - name: Download buxc
        uses: actions/download-artifact@v4
        with:
          name: buxc-linux
      - name: Prepare buxc
        run: chmod +x buxc && ./buxc --version
      - name: test-examples
        env:
          BUX_SKIP_BUILD: "1"
        run: |
          unset BUX_DEBUG_FILE || true
          make test-examples BUX_SKIP_BUILD=1
  goldens:
    name: goldens + tools
    needs: build
    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v4
      - name: Install build deps
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends \
            gcc make binutils libssl-dev python3 gdb
      - name: Download buxc
        uses: actions/download-artifact@v4
        with:
          name: buxc-linux
      - name: Prepare buxc
        run: chmod +x buxc && ./buxc --version
      - name: errors + stdlib + registry + dwarf
        env:
          BUX_SKIP_BUILD: "1"
        run: |
          unset BUX_DEBUG_FILE || true
          make test-errors BUX_SKIP_BUILD=1
          make test-stdlib BUX_SKIP_BUILD=1
          make test-registry BUX_SKIP_BUILD=1
          make test-dwarf BUX_SKIP_BUILD=1
          make test-drop-move BUX_SKIP_BUILD=1
  apps:
    name: apps
    needs: build
    runs-on: ubuntu-latest
    timeout-minutes: 25
    steps:
      - uses: actions/checkout@v4
      - name: Install build deps
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends gcc make libssl-dev
      - name: Download buxc
        uses: actions/download-artifact@v4
        with:
          name: buxc-linux
      - name: Prepare buxc
        run: chmod +x buxc && ./buxc --version
      - name: test-apps
        env:
          BUX_SKIP_BUILD: "1"
        run: |
          unset BUX_DEBUG_FILE || true
          make test-apps BUX_SKIP_BUILD=1
  selfhost:
    name: selfhost smoke
    needs: build
    runs-on: ubuntu-latest
    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v4
      - name: Install build deps
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends gcc make libssl-dev
      - name: Download buxc
        uses: actions/download-artifact@v4
        with:
          name: buxc-linux
      - name: Prepare buxc
        run: chmod +x buxc && ./buxc --version
      - name: test-selfhost-smoke
        env:
          BUX_SKIP_BUILD: "1"
        run: |
          unset BUX_DEBUG_FILE || true
          unset BUX_SELFHOST_FIXED_POINT || true
-          make test
+          make test-selfhost-smoke BUX_SKIP_BUILD=1
      - name: Upload selfhost artifacts on failure
        if: failure()
        uses: actions/upload-artifact@v4
        with:
-          name: ci-failure-logs
+          name: ci-failure-selfhost
          path: |
            build/selfhost/build/main.c
            _test_tmp_pkg/**
          if-no-files-found: ignore
  # ── macOS smoke (platform matrix) — lean: cache Nim + smoke examples ───
  # Full EXAMPLES / goldens / selfhost stay on Linux. macOS still builds
  # bootstrap + runs unit tests + a representative example subset.
  macos:
    name: macos smoke
    runs-on: macos-14
    timeout-minutes: 35
    steps:
      - uses: actions/checkout@v4
      - name: Cache Nim toolchain
        id: cache-nim
        uses: actions/cache@v4
        with:
          path: ${{ env.NIM_INSTALL_DIR }}
          # macOS builds Nim from source — cache is the main time win
          key: ${{ runner.os }}-nim-${{ env.NIM_VERSION }}-v1
      - name: Install Nim
        if: steps.cache-nim.outputs.cache-hit != 'true'
        uses: jiro4989/setup-nim-action@v2
        with:
          nim-version: ${{ env.NIM_VERSION }}
          nim-install-directory: ${{ env.NIM_INSTALL_DIR }}
          repo-token: ${{ secrets.GITHUB_TOKEN }}
      - name: PATH for cached Nim
        if: steps.cache-nim.outputs.cache-hit == 'true'
        run: |
          echo "$PWD/${{ env.NIM_INSTALL_DIR }}/bin" >> "$GITHUB_PATH"
          echo "$HOME/.nimble/bin" >> "$GITHUB_PATH"
      - name: Cache nimcache (bootstrap + unit)
        uses: actions/cache@v4
        with:
          path: nimcache
          key: ${{ runner.os }}-nimcache-macos-${{ hashFiles('bootstrap/**/*.nim', 'tests/**/*.nim') }}-v1
          restore-keys: |
            ${{ runner.os }}-nimcache-macos-
      - name: OpenSSL (Homebrew)
        run: |
          # Prefer already-installed openssl@3 (common on GHA images)
          if ! brew list openssl@3 &>/dev/null; then
            brew install openssl@3
          fi
          OPENSSL_PREFIX="$(brew --prefix openssl@3)"
          echo "OPENSSL_PREFIX=$OPENSSL_PREFIX" >> "$GITHUB_ENV"
          # buxc passes BUX_CFLAGS through to cc (needed for Homebrew libcrypto)
          echo "BUX_CFLAGS=-I${OPENSSL_PREFIX}/include -L${OPENSSL_PREFIX}/lib" >> "$GITHUB_ENV"
      - name: Build buxc
        run: |
          nim -v
          make build
      - name: unit + smoke examples
        run: |
          unset BUX_DEBUG_FILE || true
          # fmt-check is Linux-only in split CI (unit job); skip here to save time
          make test-unit
          make test-examples-smoke
  # ── Windows smoke (bootstrap + pure Nim unit tests) ─────────────────────
  # Full bux→C examples need POSIX runtime (ucontext / pthread sockets in
  # rt/runtime.c) — not ported yet. This job still catches Nim/bootstrap
  # regressions on Windows (prebuilt Nim zip = fast install).
  windows:
    name: windows smoke
    runs-on: windows-latest
    timeout-minutes: 30
    defaults:
      run:
        shell: bash
    steps:
      - uses: actions/checkout@v4
      - name: Cache Nim toolchain
        id: cache-nim
        uses: actions/cache@v4
        with:
          path: ${{ env.NIM_INSTALL_DIR }}
          key: ${{ runner.os }}-nim-${{ env.NIM_VERSION }}-v1
      - name: Install Nim
        if: steps.cache-nim.outputs.cache-hit != 'true'
        uses: jiro4989/setup-nim-action@v2
        with:
          nim-version: ${{ env.NIM_VERSION }}
          nim-install-directory: ${{ env.NIM_INSTALL_DIR }}
          repo-token: ${{ secrets.GITHUB_TOKEN }}
      - name: PATH for cached Nim
        if: steps.cache-nim.outputs.cache-hit == 'true'
        run: |
          echo "$PWD/${{ env.NIM_INSTALL_DIR }}/bin" >> "$GITHUB_PATH"
          echo "$HOME/.nimble/bin" >> "$GITHUB_PATH"
      - name: Cache nimcache (bootstrap + unit)
        uses: actions/cache@v4
        with:
          path: nimcache
          key: ${{ runner.os }}-nimcache-win-${{ hashFiles('bootstrap/**/*.nim', 'tests/**/*.nim') }}-v1
          restore-keys: |
            ${{ runner.os }}-nimcache-win-
      - name: Build buxc
        run: |
          set -e
          nim -v
          # Windows produces buxc.exe; keep name predictable for the smoke steps
          nim c --nimcache:nimcache -o:buxc.exe -d:release --opt:size bootstrap/main.nim
          ./buxc.exe --version
      - name: Pure Nim unit tests + CLI smoke
        run: |
          set -e
          unset BUX_DEBUG_FILE || true
          export NIMFLAGS=--nimcache:nimcache
          echo "Running lexer tests..."
          nim c $NIMFLAGS -r tests/lexer_test.nim
          echo "Running parser tests..."
          nim c $NIMFLAGS -r tests/parser_test.nim
          echo "Running sema tests..."
          nim c $NIMFLAGS -r tests/sema_test.nim
          echo "Running HIR tests..."
          nim c $NIMFLAGS -r tests/hir_test.nim
          echo "Running borrow checker tests..."
          nim c $NIMFLAGS -r tests/borrow_test.nim
          echo "CLI smoke..."
          rm -rf _test_tmp_pkg
          ./buxc.exe new _test_tmp_pkg
          ./buxc.exe --version
          echo "windows smoke: PASS (bootstrap + unit + CLI)"
  # ── Single required status for branch protection ────────────────────────
  ci-gate:
    name: CI gate
    if: always()
    needs: [unit, examples, goldens, apps, selfhost, macos, windows]
    runs-on: ubuntu-latest
    steps:
      - name: All jobs green?
        run: |
          set -e
          echo "unit=${{ needs.unit.result }}"
          echo "examples=${{ needs.examples.result }}"
          echo "goldens=${{ needs.goldens.result }}"
          echo "apps=${{ needs.apps.result }}"
          echo "selfhost=${{ needs.selfhost.result }}"
          echo "macos=${{ needs.macos.result }}"
          echo "windows=${{ needs.windows.result }}"
          for r in \
            "${{ needs.unit.result }}" \
            "${{ needs.examples.result }}" \
            "${{ needs.goldens.result }}" \
            "${{ needs.apps.result }}" \
            "${{ needs.selfhost.result }}" \
            "${{ needs.macos.result }}" \
            "${{ needs.windows.result }}"; do
            if [ "$r" != "success" ]; then
              echo "CI gate failed: a required job is $r"
              exit 1
            fi
          done
          echo "CI gate: all required jobs passed"
@@ -28,6 +28,10 @@ concurrency:
  group: selfhost-loop-${{ github.ref }}
  cancel-in-progress: true
 env:
  NIM_VERSION: "2.0.8"
  NIM_INSTALL_DIR: ".nim_runtime"
 jobs:
  selfhost-loop:
    name: bootstrap determinism
@@ -37,12 +41,36 @@ jobs:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Cache Nim toolchain
        id: cache-nim
        uses: actions/cache@v4
        with:
          path: ${{ env.NIM_INSTALL_DIR }}
          key: ${{ runner.os }}-nim-${{ env.NIM_VERSION }}-v1
      - name: Install Nim
        if: steps.cache-nim.outputs.cache-hit != 'true'
        uses: jiro4989/setup-nim-action@v2
        with:
-          nim-version: "2.0.x"
+          nim-version: ${{ env.NIM_VERSION }}
          nim-install-directory: ${{ env.NIM_INSTALL_DIR }}
          repo-token: ${{ secrets.GITHUB_TOKEN }}
      - name: PATH for cached Nim
        if: steps.cache-nim.outputs.cache-hit == 'true'
        run: |
          echo "$PWD/${{ env.NIM_INSTALL_DIR }}/bin" >> "$GITHUB_PATH"
          echo "$HOME/.nimble/bin" >> "$GITHUB_PATH"
      - name: Cache nimcache
        uses: actions/cache@v4
        with:
          path: nimcache
          key: ${{ runner.os }}-nimcache-loop-${{ hashFiles('bootstrap/**/*.nim', 'src/**/*.bux') }}-v1
          restore-keys: |
            ${{ runner.os }}-nimcache-loop-
            ${{ runner.os }}-nimcache-build-
      - name: Install build deps
        run: |
          sudo apt-get update
@@ -32,3 +32,4 @@ _test_*/
 # Log files
 *.log
 .nim_runtime/
@@ -2,41 +2,63 @@ NIM := nim
 SRC := bootstrap/main.nim
 OUT := buxc
 BUILD_DIR := build
 # Project-local nimcache so CI can cache compiles (default is ~/.cache/nim).
 NIMFLAGS ?= --nimcache:nimcache
-EXAMPLES := hello fibonacci factorial structs enums methods algebraic_enums generics generics_struct generic_infer generic_infer2 extend_generic pattern_matching strings strings2 map result_option try_operator ownership ownership_checked drop_early_return lifetime_elision ctfe async concurrency os_time process json iter trait_bounds channel sync jwt stdlib_ergonomics tuples func_ptr map_remove array_iter_extra string_extra multi_closure iter_hof closure_control match_let string_interp iter_generic generic_infer_hof struct_tuple_pat match_block nested_patterns match_guards pattern_shadow move_field
+EXAMPLES := hello fibonacci factorial structs enums methods algebraic_enums generics generics_struct generic_infer generic_infer2 extend_generic pattern_matching strings strings2 map result_option try_operator ownership ownership_checked ownership_release drop_early_return lifetime_elision ctfe async concurrency os_time process json iter trait_bounds channel sync jwt stdlib_ergonomics tuples func_ptr map_remove array_iter_extra string_extra multi_closure iter_hof closure_control match_let string_interp iter_generic generic_infer_hof struct_tuple_pat match_block nested_patterns match_guards pattern_shadow move_field move_field_partial c_precedence macro_twice macro_repeat macro_nested macro_hygiene macro_unhygienic
-.PHONY: all build dev debug test clean clean-all test-examples selfhost test-golden test-errors test-stdlib selfhost-loop lsp fmt-check docs bench test-apps test-dwarf test-selfhost-smoke
+# Platform smoke (macOS CI): full EXAMPLES still runs on Linux.
 EXAMPLES_SMOKE := hello ownership ownership_release strings map move_field move_field_partial c_precedence macro_twice macro_repeat macro_nested macro_hygiene macro_unhygienic
 .PHONY: all build dev debug test clean clean-all test-examples test-examples-smoke selfhost test-golden test-errors test-stdlib selfhost-loop lsp fmt-check docs bench test-apps test-dwarf test-selfhost-smoke test-unit ensure-buxc
 all: build
-build:
+# Rebuild only when bootstrap sources change (CI can set BUX_SKIP_BUILD=1
-	$(NIM) c -o:$(OUT) -d:release --opt:size $(SRC)
+# after downloading a prebuilt buxc artifact).
 $(OUT): $(wildcard bootstrap/*.nim)
 	$(NIM) c $(NIMFLAGS) -o:$(OUT) -d:release --opt:size $(SRC)
 	# strip $(OUT)
 build: $(OUT)
 # CI parallel jobs download buxc and set BUX_SKIP_BUILD=1 to avoid rebuild.
 ensure-buxc:
 ifeq ($(BUX_SKIP_BUILD),1)
 	@test -x ./$(OUT) || (echo "error: ./$(OUT) missing (BUX_SKIP_BUILD=1)"; exit 1)
 else
 	@$(MAKE) $(OUT)
 endif
 dev:
-	$(NIM) c -o:buxc_debug -d:debug --stackTrace:on --lineTrace:on $(SRC)
+	$(NIM) c $(NIMFLAGS) -o:buxc_debug -d:debug --stackTrace:on --lineTrace:on $(SRC)
 debug: dev
 	@echo "Debug binary: buxc_debug"
-test: build fmt-check test-examples test-errors test-stdlib test-registry test-dwarf test-apps test-selfhost-smoke
+# Full local / sequential suite (same coverage as split CI jobs combined).
 test: build fmt-check test-examples test-errors test-stdlib test-registry test-dwarf test-drop-move test-apps test-selfhost-smoke test-unit
 # Nim unit tests + tiny CLI smoke (needs Nim + buxc).
 test-unit: ensure-buxc
 	@echo "Running lexer tests..."
-	$(NIM) c -r tests/lexer_test.nim
+	$(NIM) c $(NIMFLAGS) -r tests/lexer_test.nim
 	@echo "Running parser tests..."
-	$(NIM) c -r tests/parser_test.nim
+	$(NIM) c $(NIMFLAGS) -r tests/parser_test.nim
 	@echo "Running sema tests..."
-	$(NIM) c -r tests/sema_test.nim
+	$(NIM) c $(NIMFLAGS) -r tests/sema_test.nim
 	@echo "Running HIR tests..."
-	$(NIM) c -r tests/hir_test.nim
+	$(NIM) c $(NIMFLAGS) -r tests/hir_test.nim
 	@echo "Running borrow checker tests..."
-	$(NIM) c -r tests/borrow_test.nim
+	$(NIM) c $(NIMFLAGS) -r tests/borrow_test.nim
 	@echo "Running integration tests..."
 	rm -rf _test_tmp_pkg
 	./$(OUT) new _test_tmp_pkg
 	./$(OUT) --version
-test-examples: build
+# Shared loop body for full + smoke example runners.
-	@for ex in $(EXAMPLES); do \
+define run-examples
 	@for ex in $(1); do \
 		echo "=== Testing example: $$ex ==="; \
 		mkdir -p examples_pkg/$$ex/src; \
 		cp examples/$$ex.bux examples_pkg/$$ex/src/Main.bux; \
@@ -49,10 +71,23 @@ test-examples: build
 			echo '[Build]' >> examples_pkg/$$ex/bux.toml; \
 			echo 'Output = "Bin"' >> examples_pkg/$$ex/bux.toml; \
 		fi; \
-		(cd examples_pkg/$$ex && timeout 10 ../../$(OUT) run) || exit 1; \
+		if command -v timeout >/dev/null 2>&1; then \
 			(cd examples_pkg/$$ex && timeout 30 ../../$(OUT) run) || exit 1; \
 		else \
 			(cd examples_pkg/$$ex && ../../$(OUT) run) || exit 1; \
 		fi; \
 	done
 endef
 test-examples: ensure-buxc
 	$(call run-examples,$(EXAMPLES))
 	@echo "All examples passed!"
 # Subset for macOS / quick platform smoke (Linux CI runs full EXAMPLES).
 test-examples-smoke: ensure-buxc
 	$(call run-examples,$(EXAMPLES_SMOKE))
 	@echo "Smoke examples passed!"
 clean:
 	rm -f $(OUT) buxc_debug
 	rm -rf $(BUILD_DIR)
@@ -65,7 +100,7 @@ clean-all: clean
 	rm -rf build/selfhost build/selfhost-loop-a build/selfhost-loop-b build/selfhost-loop-c
 	rm -rf tests/golden/*/build
-selfhost: build
+selfhost: ensure-buxc
 	@echo "=== Building self-hosted compiler ==="
 	@rm -rf build/selfhost
 	@mkdir -p build/selfhost/src
@@ -80,7 +115,7 @@ selfhost: build
 GOLDEN_TESTS := hello fibonacci structs generics algebraic_enums enums methods strings modern_features
-test-golden: build
+test-golden: ensure-buxc
 	@echo "=== Golden tests ==="
 	@passed=0; failed=0; \
 	for test in $(GOLDEN_TESTS); do \
@@ -100,24 +135,24 @@ test-golden: build
 	echo "Golden tests: $$passed passed, $$failed failed"; \
 	if [ $$failed -gt 0 ]; then exit 1; fi
-test-errors: build
+test-errors: ensure-buxc
 	@echo "=== Error diagnostic golden tests ==="
 	@chmod +x tests/error_golden/run.sh
 	@tests/error_golden/run.sh ./$(OUT)
-test-stdlib: build
+test-stdlib: ensure-buxc
 	@echo "=== Stdlib golden tests ==="
 	@chmod +x tests/stdlib_golden/run.sh
 	@tests/stdlib_golden/run.sh ./$(OUT)
 # Generate stdlib API docs from /// comments → docs/api/stdlib.md
-docs: build
+docs: ensure-buxc
 	@mkdir -p docs/api
 	@./$(OUT) doc --out docs/api/stdlib.md lib/
 	@echo "docs/api/stdlib.md updated"
 # CI: full-tree format check (lib / examples / src / tests / apps) + dirty-path smoke.
-fmt-check: build
+fmt-check: ensure-buxc
 	@echo "=== fmt --check (full tree) ==="
 	@./$(OUT) fmt --check lib/
 	@./$(OUT) fmt --check examples/
@@ -134,7 +169,7 @@ fmt-check: build
 # One-shot reformat of the same trees (run before committing style-only fixes)
 .PHONY: fmt
-fmt: build
+fmt: ensure-buxc
 	@./$(OUT) fmt lib/
 	@./$(OUT) fmt examples/
 	@./$(OUT) fmt src/
@@ -144,7 +179,7 @@ fmt: build
 # Fixed-point: bootstrap buxc → buxc2 → buxc3 (path-normalized C + stripped ELF).
 # Slow; not part of default `make test`. Optional CI: .github/workflows/selfhost-loop.yml
-selfhost-loop: build
+selfhost-loop: ensure-buxc
 	@chmod +x tools/selfhost_loop.sh
 	@tools/selfhost_loop.sh
@@ -194,42 +229,53 @@ test-lsp: lsp
 	@echo "==> LSP type hierarchy smoke"
 	@chmod +x tools/smoke_lsp_type_hierarchy.sh
 	@tools/smoke_lsp_type_hierarchy.sh
 	@echo "==> LSP type hierarchy workspace (closed multi-file)"
 	@chmod +x tools/smoke_lsp_type_hierarchy_ws.sh
 	@tools/smoke_lsp_type_hierarchy_ws.sh
 .PHONY: test-registry
-test-registry: build
+test-registry: ensure-buxc
 	@echo "=== Registry smoke (E.1 + HTTP) ==="
 	@chmod +x tools/smoke_registry.sh
 	@tools/smoke_registry.sh
 # E.2 — build showcase apps + simpledb/jwt CLI smoke
 .PHONY: test-apps
-test-apps: build
+test-apps: ensure-buxc
 	@echo "=== Apps smoke (E.2) ==="
 	@chmod +x tools/smoke_apps.sh
 	@tools/smoke_apps.sh
 # E.5 — micro-benchmarks (Bux + C/Nim/Zig twins)
 .PHONY: bench
-bench: build
+bench: ensure-buxc
 	@chmod +x tools/bench.sh
 	@tools/bench.sh
 # E.5 — Nexus HTTP throughput (wrk); optional via BENCH_NEXUS=1 make bench
 .PHONY: bench-nexus
-bench-nexus: build
+bench-nexus: ensure-buxc
 	@chmod +x tools/bench_nexus.sh
 	@tools/bench_nexus.sh
 # E.4 — DWARF / #line debugger smoke
 .PHONY: test-dwarf
-test-dwarf: build
+test-dwarf: ensure-buxc
 	@echo "=== DWARF / #line smoke (E.4) ==="
 	@chmod +x tools/smoke_dwarf.sh
 	@tools/smoke_dwarf.sh
 # Drop / field-move goldens (whole + partial field move; early-return counts)
 .PHONY: test-drop-move
 test-drop-move: ensure-buxc
 	@echo "=== Drop / field-move smoke ==="
 	@chmod +x tools/smoke_drop_move.sh
 	@tools/smoke_drop_move.sh
 # Selfhost (buxc2): move_field ownership + multi-file #line (session 41/42)
 # When BUX_SKIP_BUILD=1, reuse prebuilt buxc; still builds buxc2 via selfhost.
 .PHONY: test-selfhost-smoke
-test-selfhost-smoke: selfhost
+test-selfhost-smoke: ensure-buxc selfhost
 	@echo "=== Selfhost smoke (move_field + multi-file #line) ==="
 	@chmod +x tools/smoke_selfhost.sh
 	@tools/smoke_selfhost.sh
@@ -237,7 +237,7 @@ func Main() -> int {
 | **Backend** | LIR → C transpiler (clean 3-address code, then gcc/clang) |
 | **Strings** | Raw multi-line backticks, `f"..."` interp (bootstrap), `ReplaceAll` / `IsBlank` / `Repeat` |
 | **Gradual Ownership** | `@[Checked]` + `@[Release]` + `@[Shared]` + `borrow &mut` / `borrow &` |
-| **Drop Trait** | Auto-drop for `@[Drop]` types (Array, Map, user-defined structs) |
+| **Drop / RAII** | Auto-drop (`@[Drop]` / `extend … for Drop`); **field-move skips Drop** (no double-free) |
 | **Green Threads** | M:N scheduler (ucontext + SIGVTALRM), work-stealing queues |
 | **Async/Await** | `async func`, `spawn`, `.await` with stackful coroutines |
 | **Concurrency** | `Task`/`Channel`/`Sync` (pthread-based), `bux_async_yield`/`spawn` |
@@ -318,8 +318,11 @@ make test-examples
 # Golden diagnostic tests (Rust-style error format)
 make test-errors
-# Full unit + example suite (also run on every PR via GitHub Actions `ci.yml`)
+# Full unit + example suite (local; CI splits the same coverage across jobs)
 make test
 # Individual suites (also used by .github/workflows/ci.yml in parallel):
 #   make test-unit / test-examples / test-errors / test-stdlib /
 #   test-registry / test-dwarf / test-apps / test-selfhost-smoke
 # Full-tree format check (lib/ examples/ src/ tests/ apps/)
 make fmt-check
@@ -133,6 +133,7 @@ type
    ekMatch
    ekStringInterp
    ekClosure
    ekMacroCall       ## name!(args) — expanded before sema
  MatchArm* = object
    loc*: SourceLocation
@@ -236,6 +237,12 @@ type
      captureCount*: int
      captureNames*: seq[string]
      captureTypeKinds*: seq[int]
    of ekMacroCall:
      exprMacroName*: string
      exprMacroArgs*: seq[Expr]
      ## Group lengths for multi-rep: `m!(1,2; 3,4)` → @[2, 2].
      ## Empty means a single group of all args.
      exprMacroGroupLens*: seq[int]
  # ---------------------------------------------------------------------------
  # Statements
@@ -258,6 +265,7 @@ type
    skDefer
    skSwitch
    skDecl
    skMacroRep          ## $( … )* template repetition (macro body only)
  ElseIf* = object
    loc*: SourceLocation
@@ -330,6 +338,8 @@ type
      stmtSwitchDefault*: Block
    of skDecl:
      stmtDecl*: Decl
    of skMacroRep:            ## $( stmts… )* in macro templates
      stmtMacroRepBody*: Block
  # ---------------------------------------------------------------------------
  # Type Parameters (for generics with trait bounds)
@@ -356,6 +366,28 @@ type
    dkExternFunc
    dkExternVar
    dkExternBlock
    dkMacro           ## macro! name { ($x:expr) => { … } }
  ## One declarative macro arm: ($a:expr, $($x:expr),*) => { template }
  MacroFragKind* = enum
    mfkExpr               ## any expression
    mfkIdent              ## bare identifier (after expand must be ekIdent)
    mfkTt                 ## token-tree (MVP: same as expr)
    mfkLiteral            ## int/float/string/char/bool literal only
    mfkBlock              ## block expression `{ … }`
  MacroFragment* = object
    name*: string              ## primary / first name (compat)
    kind*: MacroFragKind       ## primary kind (compat)
    names*: seq[string]        ## one or more $names (compound rep: $a,$b)
    kinds*: seq[MacroFragKind] ## parallel to names
    isRep*: bool               ## true for $( … ),*  or  $( … )*
    repSep*: string            ## "," if separator was present before *, else ""
  MacroRule* = object
    loc*: SourceLocation
    frags*: seq[MacroFragment]
    body*: Block            ## template (substituted, then used as ekBlock)
  Param* = object
    loc*: SourceLocation
@@ -448,6 +480,9 @@ type
      declExtBlockDll*: string
      declExtBlockCallConv*: CallingConvention
      declExtBlockItems*: seq[Decl]
    of dkMacro:
      declMacroName*: string
      declMacroRules*: seq[MacroRule]
  # ---------------------------------------------------------------------------
  # Module (AST root)
@@ -4,6 +4,7 @@ import source_location
 import fmt
 import docgen
 import registry
 import macroexpand
 type
  ColorMode* = enum
@@ -653,6 +654,12 @@ proc cmdCheck*(args: seq[string], opts: GlobalOptions): int =
  if status != 0:
    return status
  let unifiedModule = mergeProject(pctx)
  let macRes = expandMacros(unifiedModule)
  if macRes.diagnostics.len > 0:
    printError("macro expansion errors", useColor)
    for d in macRes.diagnostics:
      printDiagnostic("error", d.message, d.loc, useColor)
    return 1
  let semaRes = analyze(unifiedModule)
  if semaRes.hasErrors:
    printError("type errors in project", useColor)
@@ -689,6 +696,7 @@ proc getDeclName(d: Decl): string =
  of dkInterface: d.declInterfaceName
  of dkConst: d.declConstName
  of dkTypeAlias: d.declAliasName
  of dkMacro: d.declMacroName
  else: ""
 proc collectDepDecls(lock: Lockfile, root: string, opts: GlobalOptions): seq[Decl] =
@@ -763,6 +771,14 @@ proc cmdBuild*(args: seq[string], opts: GlobalOptions): int =
  let unifiedModule = mergeProject(pctx)
  # Phase 2b: expand declarative macro! / quote! before type checking
  let macRes = expandMacros(unifiedModule)
  if macRes.diagnostics.len > 0:
    printError("macro expansion errors", useColor)
    for d in macRes.diagnostics:
      printDiagnostic("error", d.message, d.loc, useColor)
    return 1
  # Phase 3: Sema + HIR + C codegen on unified module
  let (semaRes, semaCtx) = analyzeFull(unifiedModule)
  if semaRes.hasErrors:
@@ -809,7 +825,9 @@ proc cmdBuild*(args: seq[string], opts: GlobalOptions): int =
  let optFlags = if opts.release: "-O2 -DNDEBUG" else: "-O0 -g"
  let extraCflags = getEnv("BUX_CFLAGS")
  let cflags = if extraCflags.len > 0: optFlags & " " & extraCflags else: optFlags
-  let ccCmd = &"cc {cflags} -pthread -Wl,--build-id=none -o {outputFile} {cFile} {runtimeDst} {ioDst} -lm -lcrypto 2>&1"
+  # --build-id is GNU ld only (breaks Apple ld). Reproducible selfhost-loop uses Linux CI.
  let ldStable = when defined(linux): " -Wl,--build-id=none" else: ""
  let ccCmd = &"cc {cflags} -pthread{ldStable} -o {outputFile} {cFile} {runtimeDst} {ioDst} -lm -lcrypto 2>&1"
  if opts.verbose:
    printInfo(&"running: {ccCmd}", useColor)
  let (output, exitCode) = execCmdEx(ccCmd)
@@ -85,12 +85,23 @@ proc markMovedOutLocal(ctx: var LowerCtx, name: string) =
  if name.len > 0 and ctx.hasPendingDrop(name):
    ctx.movedOutLocals.incl(name)
 # Forward decls (used by markMovedOutFromAst before their full definitions)
 proc resolveExprType(ctx: var LowerCtx, expr: Expr): Type
 proc autoDropFuncName(ctx: var LowerCtx, ty: Type): string
 proc markMovedOutFromAst(ctx: var LowerCtx, expr: Expr) =
  ## Mark droppable locals used by-value in ownership-taking contexts.
  ## Partial field moves: `return bag.items` / `let x = bag.items` mark `bag`
  ## so auto-Drop of the parent is skipped — **only when the field type itself
  ## is droppable** (not `return bag.tag` for an int field).
  if expr == nil: return
  case expr.kind
  of ekIdent:
    ctx.markMovedOutLocal(expr.exprIdent)
  of ekField:
    let fieldTy = ctx.resolveExprType(expr)
    if ctx.autoDropFuncName(fieldTy).len > 0:
      ctx.markMovedOutFromAst(expr.exprFieldObj)
  of ekStructInit:
    for f in expr.exprStructInitFields:
      ctx.markMovedOutFromAst(f.value)
@@ -2131,6 +2142,11 @@ proc lowerStmt(ctx: var LowerCtx, stmt: Stmt): HirNode =
    return HirNode(kind: hLit, litToken: Token(kind: tkIntLiteral, text: "0", loc: loc),
                   typ: makeVoid(), loc: loc)
  of skMacroRep:
    # Expanded before lowering
    return HirNode(kind: hLit, litToken: Token(kind: tkIntLiteral, text: "0", loc: loc),
                   typ: makeVoid(), loc: loc)
 proc lowerBlock(ctx: var LowerCtx, blk: Block, asExpr = false): HirNode =
  ## asExpr=true: block is used as a value (`let x = { ... }`, match arm body).
  ## Last skExpr becomes the block result. Statement blocks (func body, if/while)
@@ -2168,15 +2184,30 @@ proc lowerBlock(ctx: var LowerCtx, blk: Block, asExpr = false): HirNode =
    expr = last.blockExpr
  # Scope exit: Drop locals introduced in this block (not outer ones).
  # Skip Drop for block result and any moved-out locals (field / let / return move).
  # If the last statement always returns, drops were already injected on that
  # path — re-emitting them here produces dead double-Drop after `return`.
  proc blockAlwaysReturns(n: HirNode): bool =
    if n == nil: return false
    if n.kind == hReturn: return true
    if n.kind == hBlock:
      if n.blockStmts.len == 0: return false
      return blockAlwaysReturns(n.blockStmts[^1])
    false
  var skipDrop = ""
  if expr != nil and expr.kind == hVar:
    skipDrop = expr.varName
    ctx.markMovedOutLocal(expr.varName)
-  if ctx.deferStmts.len > deferBase:
+  let lastAlwaysReturns = stmts.len > 0 and blockAlwaysReturns(stmts[^1])
  if ctx.deferStmts.len > deferBase and not lastAlwaysReturns:
    for i in countdown(ctx.deferStmts.len - 1, deferBase):
      if not ctx.shouldSkipDrop(ctx.deferStmts[i], skipDrop):
        stmts.add(ctx.deferStmts[i])
    ctx.deferStmts.setLen(deferBase)
  elif ctx.deferStmts.len > deferBase and lastAlwaysReturns:
    # Return path already owns these drops; pop so outer scopes don't re-run them
    # for the same locals when this block is nested. Outer live locals remain.
    ctx.deferStmts.setLen(deferBase)
  let typ = if expr != nil and expr.typ != nil: expr.typ else: makeVoid()
  return hirBlock(stmts, expr, typ, blk.loc, isScope = true)
@@ -464,6 +464,17 @@ proc scanSymbol(lex: var Lexer, startLoc: SourceLocation): Token =
      return lex.makeToken(tkCaretAssign, startLoc, startPos)
    else:
      return lex.makeToken(tkCaret, startLoc, startPos)
  of '$':
    # $name fragment, or bare $ for macro repetition $( ... )*
    if isIdentStart(lex.peek()):
      discard lex.advance()  # first ident char ( $ already consumed as c1)
      while not lex.isAtEnd() and isIdentChar(lex.peek()):
        discard lex.advance()
      # text includes leading '$'
      return lex.makeToken(tkIdent, startLoc, startPos)
    else:
      # bare $ (c1 already consumed)
      return lex.makeToken(tkDollar, startLoc, startPos)
  of '#':
    # Check for intrinsics: #line, #column, #file, #function, #date, #time, #module
    let afterHash = lex.peek()
@@ -120,14 +120,15 @@ proc emitInstr(be: var LirCBackend, instr: LirInstr) =
      of lirShl: "<<"
      of lirShr: ">>"
      else: "?"
-    be.emitLine(&"{v(instr.dst)} = {v(instr.src)} {op} {v(instr.src2)};")
+    # Parenthesize so future non-temp operands cannot be rewritten by C precedence
    be.emitLine(&"{v(instr.dst)} = ({v(instr.src)} {op} {v(instr.src2)});")
  of lirNeg:
-    be.emitLine(&"{v(instr.dst)} = -{v(instr.src)};")
+    be.emitLine(&"{v(instr.dst)} = -({v(instr.src)});")
  of lirNot:
-    be.emitLine(&"{v(instr.dst)} = !{v(instr.src)};")
+    be.emitLine(&"{v(instr.dst)} = !({v(instr.src)});")
  of lirBNot:
-    be.emitLine(&"{v(instr.dst)} = ~{v(instr.src)};")
+    be.emitLine(&"{v(instr.dst)} = ~({v(instr.src)});")
  # ── Comparison ──
  of lirCmpEq, lirCmpNe, lirCmpLt, lirCmpLe, lirCmpGt, lirCmpGe:
@@ -21,12 +21,14 @@ type
    pos: int
    diagnostics: seq[ParserDiagnostic]
    structInitAllowed: bool  ## disabled inside if/while/for/match conditions
    macroTemplateMode: bool  ## true while parsing macro! rule body (allows $(…)*)
 proc initParser*(tokens: seq[Token], sourceName: string = "<input>"): Parser =
  result.tokens = tokens
  result.sourceName = sourceName
  result.pos = 0
  result.structInitAllowed = true
  result.macroTemplateMode = false
 # ---------------------------------------------------------------------------
 # Token helpers
@@ -152,7 +154,7 @@ proc synchronize(p: var Parser) =
    if p.previous.kind == tkSemicolon: return
    case p.peek()
    of tkFunc, tkStruct, tkEnum, tkUnion, tkInterface, tkExtend,
-       tkModule, tkImport, tkConst, tkType, tkExtern, tkPub:
+       tkModule, tkImport, tkConst, tkType, tkExtern, tkPub, tkMacro:
      return
    else:
      discard p.advance()
@@ -183,7 +185,10 @@ type
    release*: bool             ## @[Release] — explicit zero-cost (no borrow checks)
 proc parseAttrs(p: var Parser): ParsedAttrs =
-  while p.check(tkAt):
+  while true:
    p.skipNewlines()
    if not p.check(tkAt):
      break
    discard p.advance()  # @
    discard p.expect(tkLBracket, "expected '[' after '@'")
    let name = p.expect(tkIdent, "expected attribute name").text
@@ -728,7 +733,43 @@ proc parsePostfix(p: var Parser): Expr =
      left = Expr(kind: ekTry, loc: loc, exprTryOperand: left, exprTryType: nil)
    of tkBang:
      discard p.advance()
-      left = Expr(kind: ekUnwrap, loc: loc, exprUnwrapOperand: left)
+      # name!(args) → declarative macro call (not unwrap)
      if left.kind == ekIdent and p.check(tkLParen):
        discard p.advance()  # (
        var margs: seq[Expr] = @[]
        var groupLens: seq[int] = @[]
        var curGroup = 0
        while not p.check(tkRParen) and not p.isAtEnd:
          p.skipNewlines()
          if p.check(tkRParen): break
          # `;` starts a new arg group for multi-rep patterns
          if p.check(tkSemicolon):
            discard p.advance()
            groupLens.add(curGroup)
            curGroup = 0
            p.skipNewlines()
            continue
          margs.add(p.parseExpr())
          inc curGroup
          p.skipNewlines()
          if p.check(tkComma):
            discard p.advance()
          elif p.check(tkSemicolon):
            discard
            # handled at loop top
          else:
            # allow end of args
            discard
        if curGroup > 0 or groupLens.len == 0:
          groupLens.add(curGroup)
        # single group of all args → empty groupLens means "one group" for expander
        if groupLens.len == 1:
          groupLens = @[]
        discard p.expect(tkRParen, "expected ')' to close macro arguments")
        left = Expr(kind: ekMacroCall, loc: loc, exprMacroName: left.exprIdent,
                    exprMacroArgs: margs, exprMacroGroupLens: groupLens)
      else:
        left = Expr(kind: ekUnwrap, loc: loc, exprUnwrapOperand: left)
    of tkLBrace:
      if p.structInitAllowed and left.kind in {ekIdent, ekPath, ekGenericCall}:
        discard p.advance()
@@ -952,7 +993,26 @@ proc parseBlock(p: var Parser): Block =
 # ---------------------------------------------------------------------------
 proc parseStmt(p: var Parser): Stmt =
  while p.check(tkNewLine):
    discard p.advance()
  let loc = p.currentLoc
  # Macro template repetition: $( stmts… )*
  if p.macroTemplateMode and p.check(tkDollar) and p.peek(1) == tkLParen:
    discard p.advance()  # $
    discard p.advance()  # (
    var stmts: seq[Stmt] = @[]
    while not p.check(tkRParen) and not p.isAtEnd:
      while p.check(tkNewLine):
        discard p.advance()
      if p.check(tkRParen) or p.isAtEnd:
        break
      stmts.add(p.parseStmt())
    discard p.expect(tkRParen, "expected ')' to close macro repetition")
    discard p.expect(tkStar, "expected '*' after macro repetition")
    if p.check(tkSemicolon):
      discard p.advance()
    return Stmt(kind: skMacroRep, loc: loc,
                stmtMacroRepBody: Block(loc: loc, stmts: stmts))
  case p.peek()
  of tkLet, tkVar:
    let isMut = p.peek() == tkVar
@@ -1561,6 +1621,145 @@ proc parseExternDecl(p: var Parser, isPublic: bool, attrs: ParsedAttrs): Decl =
    return Decl(kind: dkExternVar, loc: loc, isPublic: isPublic,
                declExtVarName: vName, declExtVarType: vType)
 proc parseMacroFragKind(p: var Parser, kindTok: Token): MacroFragKind =
  case kindTok.text
  of "expr": mfkExpr
  of "ident": mfkIdent
  of "tt": mfkTt
  of "literal", "lit": mfkLiteral
  of "block": mfkBlock
  else:
    p.emitError(kindTok.loc,
      "unsupported macro fragment kind '" & kindTok.text &
      "' (expr|ident|tt|literal|block)")
    mfkExpr
 proc parseMacroFragment(p: var Parser): MacroFragment =
  ## $name:kind  (single non-rep fragment)
  let fragTok = p.expect(tkIdent, "expected $name fragment in macro pattern")
  if not fragTok.text.startsWith("$"):
    p.emitError(fragTok.loc, "macro fragment must start with '$' (e.g. $x:expr)")
  discard p.expect(tkColon, "expected ':' after macro fragment name")
  let kindTok = p.expect(tkIdent, "expected fragment kind (expr|ident|tt|literal|block)")
  let k = p.parseMacroFragKind(kindTok)
  result = MacroFragment(
    name: fragTok.text,
    kind: k,
    names: @[fragTok.text],
    kinds: @[k],
    isRep: false,
    repSep: "")
 proc parseMacroRepGroup(p: var Parser): MacroFragment =
  ## $( $a:kind , $b:kind , … ) ,*   or  … )*
  ## Compound: multiple frags inside one rep → parallel lists (zipped).
  discard p.expect(tkDollar, "expected '$'")
  discard p.expect(tkLParen, "expected '(' after '$'")
  p.skipNewlines()
  var names: seq[string] = @[]
  var kinds: seq[MacroFragKind] = @[]
  while not p.check(tkRParen) and not p.isAtEnd:
    let fragTok = p.expect(tkIdent, "expected $name inside repetition")
    if not fragTok.text.startsWith("$"):
      p.emitError(fragTok.loc, "macro fragment must start with '$'")
    discard p.expect(tkColon, "expected ':' after fragment name")
    let kindTok = p.expect(tkIdent, "expected fragment kind")
    names.add(fragTok.text)
    kinds.add(p.parseMacroFragKind(kindTok))
    p.skipNewlines()
    if p.check(tkComma):
      discard p.advance()
      p.skipNewlines()
    else:
      break
  if names.len == 0:
    p.emitError(p.currentLoc, "empty macro repetition group")
    names.add("$x")
    kinds.add(mfkExpr)
  discard p.expect(tkRParen, "expected ')' after repeated fragment(s)")
  var sep = ""
  if p.check(tkComma):
    discard p.advance()
    sep = ","
  discard p.expect(tkStar, "expected '*' after macro repetition")
  result = MacroFragment(
    name: names[0],
    kind: kinds[0],
    names: names,
    kinds: kinds,
    isRep: true,
    repSep: sep)
 proc parseMacroDecl(p: var Parser, isPublic: bool): Decl =
  ## macro! name {
  ##   ( $a:ident, $($x:expr),* ) => { … }
  ##   ( $($a:expr, $b:expr),* ) => { … }          # compound / zipped
  ##   ( $($x:expr),* ; $($y:expr),* ) => { … }    # multi-rep groups
  ## }
  let loc = p.currentLoc
  discard p.expect(tkMacro, "expected 'macro'")
  discard p.expect(tkBang, "expected '!' after macro")
  let name = p.expect(tkIdent, "expected macro name").text
  p.skipNewlines()
  discard p.expect(tkLBrace, "expected '{' to start macro body")
  var rules: seq[MacroRule] = @[]
  while not p.check(tkRBrace) and not p.isAtEnd:
    p.skipNewlines()
    if p.check(tkRBrace) or p.isAtEnd:
      break
    let rloc = p.currentLoc
    discard p.expect(tkLParen, "expected '(' to start macro pattern")
    var frags: seq[MacroFragment] = @[]
    while not p.check(tkRParen) and not p.isAtEnd:
      p.skipNewlines()
      if p.check(tkRParen): break
      # Group separator for multi-rep: `;` between pattern elements
      if p.check(tkSemicolon):
        discard p.advance()
        p.skipNewlines()
        continue
      # $( … ),*  compound or single rep
      if p.check(tkDollar) and p.peek(1) == tkLParen:
        frags.add(p.parseMacroRepGroup())
        p.skipNewlines()
        # optional `;` after rep continues with more elements
        if p.check(tkSemicolon):
          discard p.advance()
          p.skipNewlines()
          continue
        if p.check(tkComma):
          discard p.advance()
          p.skipNewlines()
          continue
        # no more separators → only rparen expected next
        break
      else:
        frags.add(p.parseMacroFragment())
        p.skipNewlines()
        if p.check(tkComma):
          discard p.advance()
        elif p.check(tkSemicolon):
          discard p.advance()
        else:
          break
    discard p.expect(tkRParen, "expected ')' to close macro pattern")
    p.skipNewlines()
    discard p.expect(tkFatArrow, "expected '=>' after macro pattern")
    p.skipNewlines()
    let savedTpl = p.macroTemplateMode
    p.macroTemplateMode = true
    let body = p.parseBlock()
    p.macroTemplateMode = savedTpl
    rules.add(MacroRule(loc: rloc, frags: frags, body: body))
    p.skipNewlines()
    if p.check(tkComma) or p.check(tkSemicolon):
      discard p.advance()
  discard p.expect(tkRBrace, "expected '}' to close macro")
  if rules.len == 0:
    p.emitError(loc, "macro '" & name & "' has no rules")
  return Decl(kind: dkMacro, loc: loc, isPublic: isPublic,
              declMacroName: name, declMacroRules: rules)
 proc parseDecl(p: var Parser): Decl =
  let loc = p.currentLoc
  var isPublic = false
@@ -1606,6 +1805,8 @@ proc parseDecl(p: var Parser): Decl =
    return p.parseTypeAliasDecl(isPublic)
  of tkExtern:
    return p.parseExternDecl(isPublic, attrs)
  of tkMacro:
    return p.parseMacroDecl(isPublic)
  else:
    p.emitError(loc, "expected declaration")
    p.synchronize()
@@ -41,7 +41,8 @@ type
    # Interface name -> interface decl
    interfaceTable*: Table[string, Decl]
    # Borrow checker state
-    checkedFunc*: bool  ## true inside @[Checked] function
+    checkedFunc*: bool  ## true inside @[Checked] and not @[Release]
    releaseFunc*: bool  ## true inside @[Release] (zero-cost: no borrow checks)
    currentFuncIsAsync*: bool  ## true inside async func
    movedVars*: seq[string]  ## variables moved in current checked function
    ## Active exclusive borrows: source var → borrow site (let-bound &mut lasts for rest of fn)
@@ -1897,6 +1898,10 @@ proc checkExpr*(sema: var Sema, expr: Expr, scope: Scope): Type =
    for e in expr.exprInterpExprs:
      discard sema.checkExpr(e, scope)
    return makeStr()
  of ekMacroCall:
    # Should have been expanded before analyze; leftover is a compiler bug
    sema.emitError(expr.loc, "unexpanded macro call '" & expr.exprMacroName & "!'")
    return makeUnknown()
  of ekClosure:
    let savedRetType = sema.currentRetType
    let savedClosureDepth = sema.closureDepth
@@ -2088,6 +2093,10 @@ proc checkStmt(sema: var Sema, stmt: Stmt, scope: Scope): Type =
    else:
      discard
    return makeVoid()
  of skMacroRep:
    # Templates with $(…)* must be expanded before type-check
    sema.emitError(stmt.loc, "unexpanded macro repetition '$(…)*'")
    return makeVoid()
 # ---------------------------------------------------------------------------
 # Function body checking
 # ---------------------------------------------------------------------------
@@ -2106,8 +2115,11 @@ proc checkFunc(sema: var Sema, decl: Decl) =
  if hasTypeGeneric:
    return
  let wasChecked = sema.checkedFunc
  let wasRelease = sema.releaseFunc
  let wasAsync = sema.currentFuncIsAsync
-  sema.checkedFunc = "Checked" in decl.declAttrs
+  # C.4: @[Release] is the zero-cost escape — disables borrow checks even with @[Checked]
  sema.releaseFunc = "Release" in decl.declAttrs
  sema.checkedFunc = "Checked" in decl.declAttrs and not sema.releaseFunc
  sema.currentFuncIsAsync = decl.declFuncIsAsync
  if sema.checkedFunc:
    sema.movedVars = @[]
@@ -2139,6 +2151,7 @@ proc checkFunc(sema: var Sema, decl: Decl) =
  for tp in addedTypeParams:
    sema.typeTable.del(tp)
  sema.checkedFunc = wasChecked
  sema.releaseFunc = wasRelease
  sema.currentFuncIsAsync = wasAsync
  sema.varRefLifetime = initTable[string, string]()
  sema.returnLifetime = ""
@@ -64,6 +64,8 @@ type
    tkDyn             # dyn
    tkDefer           # defer
    tkLifetime        # 'a (lifetime parameter)
    tkMacro           # macro (declarative macro! definitions)
    tkDollar          # bare $ for macro rep $( ... )*
    ##Punctuation
    tkLParen          # (
@@ -224,6 +226,7 @@ proc keywordKind*(text: string): TokenKind =
  of "comptime": tkComptime
  of "dyn": tkDyn
  of "defer": tkDefer
  of "macro": tkMacro
  of "true", "false": tkBoolLiteral
  else: tkIdent
@@ -281,6 +284,8 @@ proc tokenKindName*(kind: TokenKind): string =
  of tkComptime: "'comptime'"
  of tkDyn: "'dyn'"
  of tkDefer: "'defer'"
  of tkMacro: "'macro'"
  of tkDollar: "'$'"
  of tkLifetime: "lifetime"
  of tkLParen: "'('"
  of tkRParen: "')'"
@@ -191,14 +191,40 @@ Use `Std::Test` module for assertions inside test code.
 ### Continuous integration
 ```bash
-make test                          # what PR CI runs
+make test                          # full sequential suite (local)
 ```
-| Workflow | When | Command |
+| Workflow | When | What runs |
-|----------|------|---------|
+|----------|------|-----------|
-| **`.github/workflows/ci.yml`** | every PR + push to `main` | `make test` |
+| **`.github/workflows/ci.yml`** | every PR + push to `main` | **split jobs** (see below) + macOS smoke |
 | **`.github/workflows/selfhost-loop.yml`** | weekly / manual / path-filtered main | `make selfhost-loop` |
-`make test` includes examples, goldens, registry, apps, DWARF, and selfhost smoke
+**`ci.yml` layout (faster PR feedback):**
 | Job | OS | Targets |
 |-----|-----|---------|
 | `build` | ubuntu | `make build` → upload `buxc` artifact |
 | `unit` | ubuntu | `fmt-check` + `test-unit` (reuse artifact) |
 | `examples` | ubuntu | `test-examples` (full list) |
 | `goldens` | ubuntu | `test-errors` + `test-stdlib` + `test-registry` + `test-dwarf` + `test-drop-move` |
 | `apps` | ubuntu | `test-apps` |
 | `selfhost` | ubuntu | `test-selfhost-smoke` |
 | `macos` | macos-14 | rebuild + `test-unit` + `test-examples-smoke` (subset) |
 | `windows` | windows-latest | rebuild `buxc.exe` + pure Nim unit tests + CLI smoke |
 | `ci-gate` | ubuntu | fails if any required job failed (branch protection) |
 **CI speed helpers:**
 - Pin Nim **2.0.8**; cache `.nim_runtime` (big win on macOS — Nim is built from source there;
  Windows uses a prebuilt Nim zip)
 - Project-local `nimcache/` via `NIMFLAGS=--nimcache:nimcache`, cached per job by source hash
 - macOS skips full EXAMPLES (Linux already runs them) and skips `fmt-check` (Linux unit job)
 - **Windows** does **not** run `bux run` examples yet: `rt/runtime.c` needs POSIX
  (`ucontext`, `pthread`, BSD sockets). Smoke still validates bootstrap + unit tests on Win.
 Parallel Linux jobs set `BUX_SKIP_BUILD=1` after downloading the `buxc` artifact.
 Locally, `make test` still runs the full suite sequentially and builds once.
 `make test-examples-smoke` runs the macOS-sized subset locally.
 `make test` includes examples, goldens, registry, apps, DWARF, unit tests, and selfhost smoke
 (not the slow gen2↔gen3 fixed-point).
 ### Selfhost loop (optional CI)
@@ -16,11 +16,13 @@ This document describes the Bux programming language as implemented by the boots
 8. [Pattern Matching](#pattern-matching)
 9. [Methods and Interfaces](#methods-and-interfaces)
 10. [Generics](#generics)
-11. [Error Handling](#error-handling)
+11. [Gradual Ownership](#gradual-ownership-phase-82--implemented) — Checked / Release / [Drop & RAII](#drop-and-raii)
-12. [Modules and Imports](#modules-and-imports)
+12. [Error Handling](#error-handling)
-13. [Async/Await](#asyncawait)
+13. [Modules and Imports](#modules-and-imports)
-14. [Operator Overloading](#operator-overloading)
+14. [Async/Await](#asyncawait)
-15. [Operators](#operators)
+15. [Operator Overloading](#operator-overloading)
 16. [Operators](#operators)
 17. [Macros](#macros)
 ---
@@ -522,32 +524,44 @@ func Main() -> int {
 ## Gradual Ownership (Phase 8.2) ✅ Implemented
-Bux introduces **gradual ownership** — opt-in borrow checking. By default, Bux is permissive like C. With `@[Checked]`, the borrow checker enforces memory safety rules.
+Bux has **gradual ownership** — opt-in borrow checking. Default is permissive
 (C-like). Turn safety on where it matters; turn it off on hot paths with zero cost.
-### Syntax
+### Three tiers
 | Mode | Attribute | Checks | Cost |
 |------|-----------|--------|------|
 | **Default** | (none) | None | Zero — raw `*T`, free aliasing |
 | **Checked** | `@[Checked]` | Moves, exclusive `&mut`, shared/`&mut` conflicts, dangling returns, elision | Compile-time only |
 | **Release** | `@[Release]` | **Forced off** (even if also `@[Checked]`) | Zero — same codegen as default |
 **Story:** write most code unchecked for speed of iteration; mark critical APIs
 `@[Checked]`; mark micro-hotspots `@[Release]` (or both) when you need C-level
 performance without false positives.
 ```bux
-// Default: permissive mode (like C/Nim) — raw pointers, no checks
+// Tier 1 — default: C-like, no borrow checker
 func QuickSort(arr: *int, len: int) {
-    for i in 0..len {
+    // free to alias, no move tracking
        arr[i] = arr[i] * 2;
    }
 }
-// Opt-in: @[Checked] enables borrow checking
+// Tier 2 — opt-in safety
@[Checked]
 func Scale(val: &mut int) {
-    *val = *val * 2;  // OK: &mut T allows mutation
+    *val = *val * 2;
 }
-@[Checked]
+// Tier 3 — zero-cost escape (e.g. hot loop helper)
-func Read(val: &int) -> int {
+@[Release]
-    return *val;       // OK: &T allows reading
+func HotInc(p: *int) {
    *p = *p + 1;   // no checks; same as default, documents intent
 }
 // Release wins over Checked when both are present
@[Checked]
-func BadWrite(val: &int) {
+@[Release]
-    *val = 42;         // ERROR: cannot write through shared reference '&T'
+func HotButDocumented(p: &mut int) {
    *p = *p + 1;   // no borrow checks
 }
 ```
@@ -586,37 +600,57 @@ Moves happen in three contexts:
 - **Assignment**: `b = a` moves `a` into `b`
 - **Return**: `return x` moves `x` out of the function
-### Rules in @[Checked] functions
+### Rules in `@[Checked]` functions (not `@[Release]`)
 - `&T` cannot be used to mutate data (compile-time error)
 - `&mut T` allows mutation
 - `*T` pointers are unrestricted (escape hatch)
 - `&mut T` coerces to `&T` and `*T`
- **Double mutable borrow**: passing `&mut x` twice to the same call is an error
+- **Double mutable borrow**: two live `&mut` of the same var (call args or let-bound)
  ```bux
-  Swap(&mut x, &mut x);  // ERROR: double mutable borrow of x
+  Swap(&mut x, &mut x);  // ERROR
  let a: &mut int = &mut x;
  let b: &mut int = &mut x;  // ERROR: exclusive mut already live
  ```
- **Use after move**: using a moved `own T` value is an error until reassigned
+- **Use while mutably borrowed**: assign/use of `x` while a let-bound `&mut x` is live
-  ```bux
+- **Shared while mut**: cannot form `&x` while `&mut x` is live
-  let msg: own String = "hello";
+- **Use after move**: using a moved `own T` until reassigned
-  Process(msg);          // move
+- **No dangling returns**: cannot return a reference to a local
  PrintLine(msg);        // ERROR: use of moved value
  msg = "reassigned";    // OK: reinitialization
  PrintLine(msg);
  ```
 - **No dangling returns**: cannot return a reference to a local (or by-value parameter)
  ```bux
  @[Checked]
  func Bad(p: &int) -> &int {
      var x: int = 1;
-      return &x;   // ERROR: cannot return reference to local variable
+      return &x;   // ERROR
  }
  ```
 ### `@[Release]` (C.4 zero-cost path)
 Use when a function must stay check-free:
 1. **Documented hot path** — same IR as unchecked, but the attribute states intent.
 2. **Override Checked** — `@[Checked] @[Release]` on a method that would otherwise inherit team-wide Checked defaults.
 There is **no runtime cost**: the attribute only disables the checker for that function body. Prefer `@[Release]` on the smallest possible surface; keep call boundaries `@[Checked]` when you still want API-level safety.
 ```bux
@[Checked]
 func SafeApi(buf: &mut int) {
    // checked here
    HotPath(buf);
 }
@[Release]
 func HotPath(p: &mut int) {
    // no move / borrow tracking — write like C
    *p = *p + 1;
 }
 ```
 ### Lifetime elision (C.1)
-In `@[Checked]` functions, most reference signatures need **no** lifetime annotations.
+In `@[Checked]` functions (and not `@[Release]`), most reference signatures need
-Elision applies the usual single-input rules:
+**no** lifetime annotations. Elision applies the usual single-input rules:
 1. Each elided input `&T` / `&mut T` parameter gets a distinct lifetime.
 2. If there is **exactly one** input lifetime, it is assigned to all elided outputs.
@@ -640,8 +674,180 @@ func Pick<'a>(a: &'a int, b: &'a int) -> &'a int {
 // Type parameters: func F<'a, T>(...)
 ```
-Unchecked functions ignore lifetime rules (C-like). Explicit `'a` is optional
+Default and `@[Release]` functions ignore lifetime rules (C-like). Explicit `'a`
-documentation when a single input would already elide correctly.
+is optional documentation when a single input would already elide correctly.
 ### Drop and RAII
 Bux uses **static destructors** (no GC): when a value goes out of scope, the
 compiler may emit `TypeName_Drop(&local)`. That is the RAII story — resources
 are released at every exit path without manual `defer` on every return.
 #### Declaring cleanup
 Two equivalent ways to opt a type into auto-drop:
 ```bux
 // 1) Attribute — compiler looks up TypeName_Drop
@[Drop]
 struct Token {
    id: int,
    counter: *int,
 }
 func Token_Drop(self: *Token) {
    // free / close / decrement …
 }
 // 2) Interface (stdlib `lib/Drop.bux`) — same static call, no vtable
 import Drop;
 extend Buffer for Drop {
    func Drop(self: *Buffer) {
        Mem_Free(self.data);
    }
 }
 ```
 Stdlib collections implement Drop (`Array_Drop`, `Map_Drop`, …). Calling
 `Array_Drop` is the same cleanup as `Array_Free` for `Array<T>`.
 #### When auto-drop runs
 Auto-drop is **not** gated on `@[Checked]`. Any function can receive injected
 `Type_Drop` at:
 | Exit | Behavior |
 |------|----------|
 | End of block / function | Drop locals still owned |
 | Early `return` | Drop all live locals **after** materializing the return value |
 | Branch scope end | Only locals from the taken branch |
 | Nested scopes | Drop in reverse order of declaration |
 ```bux
@[Drop]
 struct Token { id: int, counter: *int }
 func Token_Drop(self: *Token) { /* … */ }
 func Early(flag: int, counter: *int) -> int {
    let t: Token = Token { id: 1, counter: counter };
    if flag == 0 {
        return 0;   // still runs Token_Drop(&t)
    }
    return 1;       // Token_Drop(&t) here too
 }
 ```
 See `examples/drop_early_return.bux` for branch-local vs fallthrough counts.
 #### Field-move: skip Drop of the source (critical)
 **Problem:** a local is moved **by value** into a struct field (or another local).
 If the compiler still auto-dropped the source, you get a **double free** — the
 field and the original local would both run `Array_Drop` on the same buffer.
 **Rule:** after a **value move** out of a local, that local is **not** dropped.
 ```bux
 struct Box {
    items: Array<int>;
 }
 func MakeBox() -> Box {
    var items: Array<int> = Array_New<int>(4);
    Array_Push<int>(&items, 10);
    Array_Push<int>(&items, 20);
    // Move `items` into the field — compiler skips Drop of `items`
    let b: Box = Box { items: items };
    return b;   // also: return-by-value skips Drop of `b` (caller owns it)
 }
 ```
 What the C backend does for `MakeBox` (simplified):
 ```c
 Box MakeBox(void) {
    Array_int items = Array_New_int(4);
    Array_Push_int(&items, 10);
    Array_Push_int(&items, 20);
    Box b = (Box){ .items = items };
    return b;
    /* no Array_Drop_int(&items);  — moved into b.items */
    /* no Array_Drop on b;         — moved to caller via return */
 }
 ```
 Ownership after `MakeBox`:
 1. Heap buffer lives inside `b.items` (and later the caller's `Box`).
 2. `items` is **moved-out** → skip auto-Drop.
 3. `b` is **returned by value** → skip auto-Drop at the return site; the caller
   (or the next owner) is responsible.
 The same skip applies to:
 - **Struct field init** — `S { field: local }` (field-move)
 - **Assignment** — `a = b` when `b` is moved (value types with Drop)
 - **Call argument** by value into a consuming parameter
 - **`return x`** — move-on-return
 Live, unmoved Drop locals still clean up on error paths (e.g. early `return`
 before the move). That is intentional: only the **successful transfer** path
 skips Drop.
 Runnable check: `examples/move_field.bux` (also covered by
 `make test-selfhost-smoke` on buxc2).
 #### Partial field moves
 Moving a **droppable field** out of a local (return or `let`) also skips Drop
 of the **parent** local:
 ```bux
@[Drop]
 struct Bag {
    items: Array<int>,
    tag: int,
 }
 func Bag_Drop(self: *Bag) {
    Array_Drop<int>(&self.items);
 }
 func TakeItems() -> Array<int> {
    var items: Array<int> = Array_New<int>(4);
    Array_Push<int>(&items, 42);
    let bag: Bag = Bag { items: items, tag: 7 };
    return bag.items;   // Bag_Drop skipped — items ownership transferred
 }
 ```
 Rules:
 - Applies only when the **field type** is droppable (`Array_*`, `@[Drop]` types,
  etc.). Reading `bag.tag` (`int`) does **not** mark `bag` moved.
 - After `let moved = bag.items`, `Bag_Drop(&bag)` is skipped; `moved` owns the
  array and is auto-dropped at scope end.
 - Avoid using other droppable fields of the parent after a partial move (they
  may be left in a moved-from state without per-field Drop).
 Golden smoke: `make test-drop-move` / `examples/move_field_partial.bux`.
 #### Manual Drop and non-Drop types
 - Types **without** `@[Drop]` / `Drop` impl are never auto-dropped (plain C layout).
 - You can still call `Type_Drop(&x)` or use `defer` for explicit cleanup.
 - `@[Release]` / default functions still get auto-drop for Drop types — Release
  only turns off the **borrow checker**, not RAII.
 #### Limits (honest)
 - Partial field moves mark the **whole parent local** as moved for Drop purposes
  (not per-field Drop of remaining fields).
 - Nested `a.b.c` path moves and moving through pointers are limited.
 - Interface Drop uses a static `TypeName_Drop` symbol (zero cost), not dynamic
  dispatch through a vtable.
 - Double-free bugs in **unchecked** code that manually free *and* auto-drop are
  still possible if you free without invalidating the value — prefer one owner.
 ---
@@ -893,3 +1099,198 @@ Overloadable operators use the naming convention `TypeName_operator_<op>`:
 - `..` — Range (exclusive): `0..10`
 - `..=` — Range (inclusive): `0..=10`
 - `sizeof` — Size of type: `sizeof(Type)`
 ---
 ## Macros
 Bux supports **declarative macros**. Expansion runs after parse and before
 type-checking. Expanded AST uses **call-site** source locations (quote hygiene).
 Both bootstrap and selfhost (`buxc2`) expand macros.
 ### Definition
 ```bux
 macro! twice {
    ($x:expr) => {
        ($x) + ($x)
    }
 }
 // Trailing repetition
 macro! sum_n {
    ( $($x:expr),* ) => {
        var acc: int = 0;
        $( acc = acc + $x; )*
        acc
    }
 }
 // Compound / zip: parallel lists from interleaved args
 macro! add_pairs {
    ( $($a:expr, $b:expr),* ) => {
        var acc: int = 0;
        $( acc = acc + ($a + $b); )*
        acc
    }
 }
 // Multi-rep groups: `;` separates arg groups at the call site
 macro! sum_groups {
    ( $($x:expr),* ; $($y:expr),* ) => {
        var s: int = 0;
        $( s = s + $x; )*
        $( s = s + $y; )*
        s
    }
 }
 // Nested template repetition (outer list → inner expands once per item)
 macro! double_each_sum {
    ( $($x:expr),* ) => {
        var t: int = 0;
        $(
            $( t = t + $x; )*
            $( t = t + $x; )*
        )*
        t
    }
 }
 // ident fragment: bare identifier at the call site
 macro! call0 {
    ( $f:ident ) => {
        $f()
    }
 }
 // literal (alias: lit) — only int/float/string/char/bool literals
 macro! only_lit {
    ( $x:literal ) => { $x }
 }
 // block — only `{ … }` block expressions
 macro! wrap_block {
    ( $b:block ) => { $b }
 }
 // gensym: template locals renamed per expansion
 macro! with_acc {
    ( $start:literal ) => {
        var n: int = $start;
        n = n + 1;
        n
    }
 }
 ```
 - Introduced with the `macro!` keyword.
 - Each **rule** is `( pattern ) => { template }`.
 - **Fragment kinds:**
  | Kind | Matches |
  |------|---------|
  | `expr` | any expression |
  | `ident` | bare identifier (`ekIdent`) |
  | `tt` | token-tree (MVP: same as `expr`) |
  | `literal` / `lit` | int/float/string/char/bool literal only |
  | `block` | block expression `{ … }` |
 - Fragment names start with `$` (lexer `$ident`).
 - **Repetition:** `$( $x:expr ),*` / `$( $x:expr )*` — one or more rep fragments per pattern.
 - **Compound rep:** `$( $a:expr, $b:expr ),*` — interleaved args zip into parallel lists.
 - **Multi-rep:** two (or more) `$(…)*` in one pattern; call site uses `;` between groups:
  `sum_groups!(1, 2; 10, 20, 30)`.
 - Template `$( stmt; … )*` expands once per list item (zip when multiple lists used).
 - Nested `$( $(…)* )*`: after outer binds list items as singles, inner expands once.
 ### Invocation
 ```bux
 let n = twice!(21);
 let s = sum_n!(1, 2, 3);          // 6
 let z = sum_n!();                 // 0
 let p = add_pairs!(1, 10, 2, 20); // (1+10)+(2+20) = 33
 let g = sum_groups!(1, 2; 10, 20, 30); // 63
 let d = double_each_sum!(3, 4);   // 14
 call0!(SomeFunc);
 let a = with_acc!(10);            // 11
 let b = with_acc!(20);            // 21 — different gensym'd `n`
 let c = only_lit!(7);
 // only_lit!(1 + 2);              // ERROR: no matching rule
 let w = wrap_block!({ 1 + 2 });   // 3
 ```
 - Syntax: `name!( arg, … )` (not unwrap: unwrap is `expr!` without `(`).
 - Matching: fixed-arity by count; kind constraints; rep by groups / remaining args / chunk.
 ### Built-in `quote!`
 ```bux
 let x = quote!(1 + 2);   // identity expand; locations grafted to call site
 ```
 ### Hygiene
 Two layers (both bootstrap + selfhost):
 1. **Call-site graft** — expanded AST uses the call site’s line/col/`sourceFile`
   (so diagnostics and `#line` point at the user call, not the macro definition).
 2. **Gensym of template binders** — each expansion renames:
   - `let` / `var` locals introduced by the template
   - `for` loop binders in the template
   - Nested scopes (if/while/for bodies, MacroRep bodies)
   so two expansions of the same macro in one function do not collide under the
   C backend’s **function-scoped** locals (e.g. `__m1_n` and `__m2_n`).
 Spliced `$frags` in expression positions are **not** gensym’d — they keep
 call-site names/values.
 #### Unhygienic binders (`var $name`)
 To **introduce a binder whose name comes from the call site**, use a `$frag`
 as the binder itself. That name is **not** gensym’d:
 ```bux
 macro! let_mut {
    ( $name:ident, $init:literal ) => {
        var $name: int = $init;   // unhygienic: becomes `counter`, not __m1_…
        $name = $name + 1;
        $name
    }
 }
 // expands with local `counter` (and hygienic locals still unique)
 let a = let_mut!(counter, 10);   // 11
 let b = let_mut!(other, 20);     // 21
 macro! double_acc {
    ( $start:literal ) => {
        var acc: int = $start;   // hygienic → __m1_acc / __m2_acc
        acc = acc + acc;
        acc
    }
 }
 ```
 | Binder form | After expand | Gensym? |
 |-------------|--------------|---------|
 | `var acc = …` (plain name in template) | `__mN_acc` | yes |
 | `var $name = …` with `$name:ident` | call-site ident | **no** |
 | `for $i in …` with `$i:ident` | call-site ident | **no** |
 The binder must be a **`:ident` fragment** bound to a bare identifier. A plain
 template name is always hygienic.
 Examples: `examples/macro_hygiene.bux`, `examples/macro_unhygienic.bux`.
 ### Limits
 - Up to two named rep lists per rule on selfhost (enough for zip + multi-rep).
 - Compound chunk size currently 1 or 2.
 - Nested macro *calls* expanded recursively (depth limit 32).
 - Unhygienic binders only rename `let`/`var`/`for` binders — not full
  Scheme/Rust colored identifiers or `stmt`/`pat` token trees.
 - Macro expansion still yields a **block expression**; unhygienic names are
  scoped to that block (not automatically injected into the caller scope).
@@ -1,7 +1,7 @@
 # Bux — План към „добър“ език (v0.5 → v1.0)
-> **Дата:** 2026-07-19  
+> **Дата:** 2026-07-20  
-> **Текущо:** v0.5.x — quote/graft hygiene, LSP 0.15, CI, fixed-point  
+> **Текущо:** v0.5.x — macros (unhygienic binders + multi-rep), partial field-move, lean CI  
 > **Цел:** Език, с който се пишат реални проекти комфортно, безопасно (по избор) и с надежден toolchain.
 ---
@@ -72,7 +72,7 @@
 | C.1 | Lifetime elision за common cases | Без `'a` в 90% от API-тата | ✅ bootstrap + selfhost |
 | C.2 | Exclusive `&mut` vs shared `&` data-flow | По-малко false negatives | ✅ let-bound + use-while + call conflict |
 | C.3 | Auto-drop edge cases (early return, branches) | RAII да е надежден | ✅ bootstrap + selfhost |
-| C.4 | `@[Release]` zero-cost path документация + golden tests | Killer story: safe default, free hot path | ✅ partial (unchecked path + goldens) |
+| C.4 | `@[Release]` zero-cost path документация + golden tests | Killer story: safe default, free hot path | ✅ full (docs + Release wins + tests + example) |
 ### D — Tooling (P1)
@@ -864,9 +864,261 @@ A (stdlib ergonomics)  →  B (compiler holes)  →  C (ownership depth)
 ---
 ## Сесия 56 (CBE binary parentheses — C precedence safety)
 1. **Bug (selfhost):** tree HIR→C emitted nested binaries **without** parens.
   - `return (a + b) * c` → C `return a + b * c;` → **7** instead of **9**
   - `return (a - b) / c` → `a - b / c` → **8** instead of **3**
 2. **Fix selfhost** (`src/c_backend.bux`):
   - `hBinary` always emits `(left op right)` (same policy as bootstrap HIR CBE)
   - Unary operand parens (session 52) kept: `!(a && b)`
 3. **Bootstrap LIR** (`bootstrap/lir_c_backend.nim`): defensive parens on
   arith/bitwise and unary `!`/`-`/`~` (operands are temps today; future-proof)
 4. **Example:** `examples/c_precedence.bux` — MulSum/SubDiv/ShiftSum/Mix
 5. **Smoke:** `tools/smoke_selfhost.sh` checks run values **and** generated C
   contains `(a + b) * c` / `(a - b) / c`
 6. Wired into `EXAMPLES` + `make test-selfhost-smoke`
 7. Verified: bootstrap + **buxc2** → `9/3/6/7` + `PASS c_precedence`;
   smoke PASS
 ---
 ## Сесия 57 (CI split jobs + macOS smoke)
 1. **`.github/workflows/ci.yml`** — no longer one 90m monolithic `make test`:
   - **`build`** (ubuntu): `make build` → artifact `buxc-linux`
   - **Parallel** (reuse artifact, `BUX_SKIP_BUILD=1`):
     - `unit` — `fmt-check` + `test-unit`
     - `examples` — `test-examples`
     - `goldens` — errors + stdlib + registry + dwarf
     - `apps` — `test-apps`
     - `selfhost` — `test-selfhost-smoke`
   - **`macos`**: Homebrew OpenSSL + rebuild + fmt/unit/examples
   - **`ci-gate`**: single required status (all of the above must succeed)
 2. **Makefile:**
   - `test-unit` extracted from `test`
   - `ensure-buxc` + `BUX_SKIP_BUILD=1` for CI artifact reuse
   - `$(OUT)` rebuild only when `bootstrap/*.nim` changes
   - portable examples runner (optional `timeout`; macOS without coreutils OK)
 3. **macOS / non-GNU ld:**
   - bootstrap: `-Wl,--build-id=none` only `when defined(linux)`
   - selfhost: `bux_cc_ld_stable()` in `rt/runtime.c` (Linux-only build-id)
   - CI sets `BUX_CFLAGS=-I… -L…` for Homebrew `libcrypto`
 4. Docs: BuildAndTest + README CI table; local `make test` still full sequential
 5. Verified locally: `BUX_SKIP_BUILD=1 make fmt-check test-unit test-errors`
 ---
 ## Сесия 58 (LSP 0.16 workspace type hierarchy index)
 1. **Gap:** type hierarchy subtypes/supertypes only saw open-doc `impls` or
   method-keyed `workspaceImpls`. Closed files with **empty**
   `extend T for I {}` (no methods) returned **[]**.
 2. **`workspaceTypeRels`** (`tools/lsp_server.nim`):
   - URI → `seq[(typeName, iface, line)]` from every `analyzeFile`
   - `registerWorkspaceTypeRels` replaces per-URI (re-open / re-scan safe)
   - filled on `scanWorkspace` + open/edit — **no open doc required**
 3. **Consumers:**
   - `collectSubtypeItems` / `collectSupertypeItems` prefer type-rel index
   - `collectTypeImplementorLocs` (textDocument/implementation) same
 4. **Smoke:** `tools/smoke_lsp_type_hierarchy_ws.sh`
   - open only Main; Drawable.bux + Shapes.bux closed
   - empty extends → Drawable subtypes Circle+Square; Circle supers Drawable+Named
 5. Version **bux-lsp 0.16.0**; wired into `make test-lsp`
 6. Verified: single-file hierarchy + workspace smoke PASS
 ---
 ## Сесия 59 (user-facing `macro!` / `quote!` — declarative MVP)
 1. **Syntax (bootstrap):**
   - `macro! name { ($x:expr, …) => { template } }`
   - Invoke: `name!(args…)` — distinct from unwrap `expr!` via following `(`
   - Built-in **`quote!(e)`** — identity expand + call-site graft
 2. **Lexer:** keyword `macro`; `$ident` fragment tokens (`$x`)
 3. **AST:** `dkMacro` + `MacroRule`/`MacroFragment`; `ekMacroCall`
 4. **Expansion** (`bootstrap/macroexpand.nim`) before sema:
   - Collect macro decls; match rule by arity
   - Deep clone + substitute `$frags` + graft call-site `SourceLocation`
   - Nested expand (depth ≤ 32)
 5. **CLI:** `build` / `check` / `run` call `expandMacros` after merge
 6. **Example:** `examples/macro_twice.bux` → 42 / 42 / 43 + PASS
 7. **LanguageRef:** Macros section (limits documented)
 8. Verified: `./buxc run macro_twice`; hello + lexer/parser tests green
 9. **Not yet:** selfhost expand parity; `$(…)*` repetition; more frag kinds
 ---
 ## Сесия 60 (selfhost `macro!` / `quote!` expand parity)
 1. **Lexer/token:** `tkMacro`, keyword `macro`, `$ident` fragments
 2. **AST:** `dkMacro` (rules in `childDecl1` chain), `ekMacroCall`
 3. **Parser:** `macro! name { ($x:expr) => {…} }`, invoke `name!(…)`
 4. **`src/macroexpand.bux`:**
   - collect macros → match rule by arity → clone+subst `$frags`
   - call-site graft (line/col/`sourceFile`)
   - built-in `quote!(e)`
 5. **CLI:** expand before sema (project / check / compile paths)
 6. **Sema fixes** (needed for block templates):
   - `ekBlock` value = last `skExpr` type (was always `tyVoid`)
   - `let x: T = …` sets `sym.typeKind` from annotation (not only init)
 7. **Smoke:** `tools/smoke_selfhost.sh` runs `examples/macro_twice.bux` via buxc2
 8. Verified: **buxc2** + bootstrap → `42/42/43` + `PASS macro_twice`
 ---
 ## Сесия 61 (macro `$(…)*` + `ident`/`tt` fragments)
 1. **Fragment kinds:** `expr` | `ident` | `tt` (tt ≡ expr for now)
 2. **Pattern rep (trailing):** `$( $x:expr ),*` / `$( $x:expr )*`
 3. **Template rep:** `$( stmts… )*` → `skMacroRep`, expanded per list item
 4. **Lexer:** bare `tkDollar` for `$(…)` (vs `$ident`)
 5. **Bootstrap** `macroexpand.nim`: list bindings, match rules, gensym locals
 6. **Selfhost** parity: `useNames` encodes kinds/`rep:`, `Subst_Block_Flat`, gensym
 7. **Sema:** block-as-expr checks last value **inside** child scope (no UAF of locals)
 8. **Example:** `examples/macro_repeat.bux` — sum_n / empty / call0 / id_tt
 9. Verified: bootstrap + **buxc2** → `6/0/42/7` + `PASS macro_repeat`
 ---
 ## Сесия 62 (C.4 `@[Release]` polish + Checked docs)
 1. **Three-tier model** documented in LanguageRef:
   - default (no checks) → `@[Checked]` → `@[Release]` (force off)
 2. **Bootstrap:** `releaseFunc`; `checkedFunc = Checked ∧ ¬Release`
 3. **Selfhost:** same rule; **stacked attrs** loop (`@[Checked]` + `@[Release]`)
 4. **Parser:** multi-line stacked `@[…]` (skip newlines between attrs)
 5. **Tests** (`borrow_test`): Release alone; Checked+Release wins; Checked still errors
 6. **Example:** `examples/ownership_release.bux` — Unchecked / Safe / Hot / HotDangle
 7. Verified: 27/27 borrow tests; example PASS
 ---
 ## Сесия 63 (nested `$(…)*` / multi-rep / compound zip)
 1. **Bootstrap** (`macroexpand.nim` + parser):
   - Compound rep: `$( $a:expr, $b:expr ),*` → parallel lists, zip in template
   - Multi-rep: `$(…)* ; $(…)*` with call-site `;` groups (`exprMacroGroupLens`)
   - Nested template: outer binds list → inner `$(…)*` expands once (no list names left)
   - `MacroFragment.names` / `.kinds` for multi-name frags
 2. **Selfhost** parity (`src/macroexpand.bux`, `parser.bux`):
   - Two named rep lists + zip in `Subst_Block_Flat`
   - Kinds encoding `rep:expr+expr,@2` / multi-seg `rep:…;rep:…`
   - Macro call `;` groups → `genericCallee` group-length string
 3. **Example:** `examples/macro_nested.bux`
   - `add_pairs` → 33, `sum_groups` → 63, `double_each_sum` → 14, `named_sum` → 18
 4. **LanguageRef:** multi-rep / compound / nested docs; limits updated
 5. Verified: bootstrap + **buxc2** → PASS macro_nested / macro_repeat / macro_twice
 ---
 ## Сесия 64 (CI Nim cache + faster macOS)
 1. **Nim pin + toolchain cache:**
   - `NIM_VERSION: 2.0.8` (stable cache keys; was `2.0.x`)
   - Cache `.nim_runtime` on `build` / `unit` / `macos` / `selfhost-loop`
   - Skip `setup-nim-action` on cache hit; restore `PATH` only
 2. **`nimcache` project-local:**
   - `Makefile` `NIMFLAGS ?= --nimcache:nimcache` for bootstrap + unit tests
   - `actions/cache` keyed on `bootstrap/**/*.nim` (+ tests for unit)
 3. **Leaner macOS job:**
   - Runner `macos-14`; timeout 35m
   - `make test-unit` + `make test-examples-smoke` (not full EXAMPLES / not fmt)
   - `EXAMPLES_SMOKE`: hello, ownership*, strings, map, c_precedence, macro_*
   - OpenSSL: install only if missing (`brew list`)
 4. **Docs:** BuildAndTest CI table; `.gitignore` `.nim_runtime/`
 5. Verified locally: `make build` uses `nimcache/`; `test-examples-smoke` PASS
 ---
 ## Сесия 65 (Drop / RAII docs — field-move story)
 1. **LanguageRef — Drop and RAII** (under Gradual Ownership):
   - `@[Drop]` vs `extend T for Drop` (static `Type_Drop`, no vtable)
   - When auto-drop runs (block end, early return, branches) — not gated on Checked
   - **Field-move skip Drop** with `MakeBox` + simplified C (no `Array_Drop(&items)`)
   - Move-on-return, assignment, call-arg transfers; error-path still Drops
   - Limits: whole-local moves, static dispatch, manual free pitfalls
 2. **TOC** links Ownership + Drop; **Stdlib** `Array_Drop` + `Std::Drop` section
 3. **README** Drop line mentions field-move
 4. Cross-refs: `examples/move_field.bux`, `examples/drop_early_return.bux`,
   selfhost smoke
 5. Verified: `move_field` C has no `Array_Drop` on moved `items`; example PASS
 ---
 ## Сесия 66 (macro hygiene + frag kinds `literal` / `block`)
 1. **Fragment kinds** (bootstrap + selfhost):
   - `literal` / `lit` — only `ekLiteral` (rejects `1 + 2`)
   - `block` — only `ekBlock` `{ … }`
   - Shared `fragMatches` / `Macro_FragMatches` at match time
 2. **Hygiene gensym:**
   - Bootstrap: also rename **`for` binders**; walk for bodies in collect
   - Selfhost: gensym `skFor` + recurse if/while/for/MacroRep bodies
   - CBE: two `with_acc!` → `__m1_n` / `__m2_n` (no collision)
 3. **Example:** `examples/macro_hygiene.bux` → 11/21/7/3/42 + PASS
 4. **LanguageRef:** kind table + hygiene layers (graft + gensym)
 5. **Makefile:** `macro_hygiene` in EXAMPLES + EXAMPLES_SMOKE
 6. Verified: bootstrap + **buxc2**; negative `only_lit!(1+2)` → no matching rule
 ---
 ## Сесия 67 (CI Windows smoke)
 1. **`.github/workflows/ci.yml` — `windows` job** (`windows-latest`, bash shell):
   - Cache Nim **2.0.8** (prebuilt zip — fast) + `nimcache`
   - `nim c -o:buxc.exe` bootstrap
   - Pure Nim unit tests: lexer / parser / sema / hir / borrow
   - CLI smoke: `buxc.exe new` + `--version`
 2. **Scope (honest):** no `bux run` examples on Windows yet —
   `rt/runtime.c` is POSIX (`ucontext`, `pthread`, sockets, OpenSSL link).
   Job still gates bootstrap regressions on Win.
 3. **`ci-gate`:** `windows` is a required job
 4. **Docs:** BuildAndTest CI table + Windows note
 5. Locally: YAML validated; full Win run is on GHA only
 ---
 ## Сесия 68 (partial field moves + Drop goldens)
 1. **Bug:** `return bag.items` still ran `Bag_Drop(&bag)` → double-free /
   corrupt Array (ASSERT fail). Also dead double-Drop after terminal `return`.
 2. **Bootstrap** (`hir_lower.nim`):
   - `markMovedOutFromAst` handles `ekField` when **field type is droppable**
     (`autoDropFuncName`) — not for `return a.id` (int)
   - Scope exit: skip re-emitting drops when last stmt always-returns; pop defers
 3. **Selfhost** (`c_backend.bux`):
   - `CBE_MarkMovedFromNodeHint` + droppable type check; return uses `currentRetType`
   - Store/let rhs walks field access for partial moves
 4. **Example + golden smoke:**
   - `examples/move_field_partial.bux`
   - `tools/smoke_drop_move.sh` + `make test-drop-move` (CI goldens job)
 5. Verified: partial PASS; `TakeItems` has **no** `Bag_Drop`; drop_early_return 5;
   move_field PASS
 ---
 ## Сесия 69 (macro unhygienic binders)
 1. **Problem:** gensym renamed *all* template `let`/`var` binders, so
   `var $name: int = …` with `$name:ident` could not introduce a call-site name.
 2. **Bootstrap** (`macroexpand.nim`):
   - `binderIdentFromFrag` + `expandUnhygienic` set
   - `substStmt`: rewrite `skLet`/`skFor` binder when name is `$frag` → ekIdent
   - `collectLetNames` skips unhygienic names
 3. **Selfhost** (`macroexpand.bux`):
   - `Env_AddUnhy` / `Env_IsUnhy` / `Env_BinderFromFrag`
   - `Subst_Stmt` rewrites binders; `Macro_GensymBlock(ex, body, env)` skips them
 4. **Example:** `examples/macro_unhygienic.bux` → 11/21/6/10/1 + PASS
   - C: `counter` / `other` / `n` kept; `acc` / `scratch` → `__mN_*`
 5. **LanguageRef:** unhygienic binder table; EXAMPLES + EXAMPLES_SMOKE
 6. Verified: bootstrap + **buxc2**; macro_hygiene still PASS
 ---
 ## Следващи стъпки
-1. Parenthesize binary ops in CBE for full C precedence safety
+1. Windows: MinGW + runtime stubs for `hello` smoke (stretch)
-2. CI matrix (macOS) or split jobs for faster PR feedback
+2. Per-field Drop after partial move (stretch)
-3. Type hierarchy for multi-file closed docs without open (workspace type index)
+3. Macro: true `stmt`/`pat` token-tree frags (stretch)
 4. User-facing `macro!` / `quote` syntax on top of graft/clone
@@ -95,6 +95,12 @@ struct Array<T> {
 | `Array_Clear<T>` | `func Array_Clear<T>(arr: *Array<T>)` | Set length to 0 (keeps capacity) |
 | `Array_Reserve<T>` | `func Array_Reserve<T>(arr: *Array<T>, minCap: uint)` | Grow capacity if needed |
 | `Array_Free<T>` | `func Array_Free<T>(arr: *Array<T>)` | Free memory |
 | `Array_Drop<T>` | `func Array_Drop<T>(self: *Array<T>)` | Drop trait entry (same as `Array_Free`) |
 **RAII:** `Array<T>` is auto-dropped at scope exit. Prefer letting the compiler call
 `Array_Drop` over manual `Array_Free` when ownership is clear. If you move an
 array into a struct field, the **source local is not dropped** (see LanguageRef
 [Drop and RAII](LanguageRef.md#drop-and-raii) / `examples/move_field.bux`).
 ### Example
 ```bux
@@ -105,13 +111,31 @@ func Main() -> int {
    Array_Push<int>(&arr, 10);
    Array_Push<int>(&arr, 20);
    PrintInt(Array_Get<int>(&arr, 0));  // 10
-    Array_Free<int>(&arr);
+    // Array_Drop runs at end of Main (or call Array_Free manually)
    return 0;
 }
 ```
 ---
 ## Std::Drop
 Trait for automatic cleanup (RAII). Defined in `lib/Drop.bux`:
 ```bux
 interface Drop {
    func Drop(self: *Self);
 }
 ```
 Implement with `extend Type for Drop { func Drop(self: *Type) { … } }` or mark
 the type `@[Drop]` and provide `Type_Drop`. Full rules (early return, field-move
 skip Drop, move-on-return): **LanguageRef → Drop and RAII**.
 Examples: `examples/drop_early_return.bux`, `examples/move_field.bux`.
 ---
 ## Std::Iter
 Lightweight iterator over `Array<T>` (index-based, no allocation).
@@ -0,0 +1,53 @@
 // C precedence safety: Bux AST must survive C codegen without rewrite.
 // Mul(Add(a,b), c) must stay (a+b)*c, not a+b*c.
 import Std::Io::{PrintLine};
 import Std::String::{String_FromInt};
 func MulSum(a: int, b: int, c: int) -> int {
    // AST: (a+b)*c → 9 for (1,2,3); wrong C emit gives 1+2*3=7
    return (a + b) * c;
 }
 func SubDiv(a: int, b: int, c: int) -> int {
    // AST: (a-b)/c → 3 for (10,4,2); wrong C emit gives 10-4/2=8
    return (a - b) / c;
 }
 func ShiftSum(a: int, b: int) -> int {
    // (a+b)<<1 → 6 for (1,2)
    return (a + b) << 1;
 }
 func Mix(a: int, b: int, c: int, d: int) -> int {
    // ((a+b)*c)-d → 7 for (1,2,3,2)
    return (a + b) * c - d;
 }
 func Main() -> int {
    let m: int = MulSum(1, 2, 3);
    let s: int = SubDiv(10, 4, 2);
    let sh: int = ShiftSum(1, 2);
    let x: int = Mix(1, 2, 3, 2);
    PrintLine(String_FromInt(m));
    PrintLine(String_FromInt(s));
    PrintLine(String_FromInt(sh));
    PrintLine(String_FromInt(x));
    if m != 9 {
        PrintLine("FAIL MulSum");
        return 1;
    }
    if s != 3 {
        PrintLine("FAIL SubDiv");
        return 1;
    }
    if sh != 6 {
        PrintLine("FAIL ShiftSum");
        return 1;
    }
    if x != 7 {
        PrintLine("FAIL Mix");
        return 1;
    }
    PrintLine("PASS c_precedence");
    return 0;
 }
@@ -0,0 +1,73 @@
 // Session 66 — gensym hygiene + fragment kinds literal / block
 import Std::Io::{PrintLine};
 import Std::String::{String_FromInt};
 // Template locals are gensym'd per expansion — two uses of `n` in one Main
 // must not collide under the C backend's function-scoped locals.
 macro! with_acc {
    ( $start:literal ) => {
        var n: int = $start;
        n = n + 1;
        n
    }
 }
 // literal: only int/float/string/char/bool literals (not 1+2)
 macro! only_lit {
    ( $x:literal ) => {
        {
            $x
        }
    }
 }
 // block: only `{ … }` block expressions
 macro! wrap_block {
    ( $b:block ) => {
        $b
    }
 }
 // lit alias for literal
 macro! double_lit {
    ( $n:lit ) => {
        ($n) + ($n)
    }
 }
 func Main() -> int {
    // gensym: two expansions both introduce `n`
    let a: int = with_acc!(10);
    let b: int = with_acc!(20);
    // 11, 21
    let c: int = only_lit!(7);
    let d: int = wrap_block!({ 1 + 2 });
    let e: int = double_lit!(21);
    PrintLine(String_FromInt(a));
    PrintLine(String_FromInt(b));
    PrintLine(String_FromInt(c));
    PrintLine(String_FromInt(d));
    PrintLine(String_FromInt(e));
    if a != 11 {
        PrintLine("FAIL with_acc gensym a");
        return 1;
    }
    if b != 21 {
        PrintLine("FAIL with_acc gensym b");
        return 1;
    }
    if c != 7 {
        PrintLine("FAIL only_lit");
        return 1;
    }
    if d != 3 {
        PrintLine("FAIL wrap_block");
        return 1;
    }
    if e != 42 {
        PrintLine("FAIL double_lit");
        return 1;
    }
    PrintLine("PASS macro_hygiene");
    return 0;
 }
@@ -0,0 +1,78 @@
 // Session 63 — multi-rep patterns, compound/zipped rep, nested template $(…)*
 import Std::Io::{PrintLine};
 import Std::String::{String_FromInt};
 // Compound rep: $( $a:expr , $b:expr ),*  → parallel lists, zip in template
 macro! add_pairs {
    ( $($a:expr, $b:expr),* ) => {
        var __acc: int = 0;
        $( __acc = __acc + ($a + $b); )*
        __acc
    }
 }
 // Multi-rep groups separated by `;` in the call
 // sum_n!(1,2; 10,20,30) → sum first group + sum second group
 macro! sum_groups {
    ( $($x:expr),* ; $($y:expr),* ) => {
        var __s: int = 0;
        $( __s = __s + $x; )*
        $( __s = __s + $y; )*
        __s
    }
 }
 // Nested template: outer over $x, inner body uses current $x once
 // (same-list nested MacroRep expands once when bound as single)
 macro! double_each_sum {
    ( $($x:expr),* ) => {
        var __t: int = 0;
        $(
            $( __t = __t + $x; )*
            $( __t = __t + $x; )*
        )*
        __t
    }
 }
 // Prefix fixed + trailing rep still works
 macro! named_sum {
    ( $label:ident, $($n:expr),* ) => {
        var __u: int = 0;
        $( __u = __u + $n; )*
        __u
    }
 }
 func Main() -> int {
    let p: int = add_pairs!(1, 10, 2, 20);
    // (1+10)+(2+20) = 33
    let g: int = sum_groups!(1, 2; 10, 20, 30);
    // 1+2+10+20+30 = 63
    let d: int = double_each_sum!(3, 4);
    // (3+3)+(4+4) = 14
    let n: int = named_sum!(ignored, 5, 6, 7);
    // 18
    PrintLine(String_FromInt(p));
    PrintLine(String_FromInt(g));
    PrintLine(String_FromInt(d));
    PrintLine(String_FromInt(n));
    if p != 33 {
        PrintLine("FAIL add_pairs");
        return 1;
    }
    if g != 63 {
        PrintLine("FAIL sum_groups");
        return 1;
    }
    if d != 14 {
        PrintLine("FAIL double_each_sum");
        return 1;
    }
    if n != 18 {
        PrintLine("FAIL named_sum");
        return 1;
    }
    PrintLine("PASS macro_nested");
    return 0;
 }
@@ -0,0 +1,65 @@
 // Macro repetition $(…)* + fragment kinds expr/ident/tt (session 61)
 import Std::Io::{PrintLine};
 import Std::String::{String_FromInt};
 // Sum any number of int exprs
 // Template body is a single block (lets + $(…)* + result expr).
 macro! sum_n {
    ( $($x:expr),* ) => {
        var __sum_acc: int = 0;
        $( __sum_acc = __sum_acc + $x; )*
        __sum_acc
    }
 }
 // Bind an identifier name and call it as a zero-arg func via expr wrap
 // (ident fragment must be a bare identifier at the call site)
 macro! call0 {
    ( $f:ident ) => {
        {
            $f()
        }
    }
 }
 // tt is accepted like expr (token-tree MVP)
 macro! id_tt {
    ( $t:tt ) => {
        {
            $t
        }
    }
 }
 func FortyTwo() -> int {
    return 42;
 }
 func Main() -> int {
    let a: int = sum_n!(1, 2, 3);
    let b: int = sum_n!();
    let c: int = call0!(FortyTwo);
    let d: int = id_tt!(7);
    PrintLine(String_FromInt(a));
    PrintLine(String_FromInt(b));
    PrintLine(String_FromInt(c));
    PrintLine(String_FromInt(d));
    if a != 6 {
        PrintLine("FAIL sum_n 1+2+3");
        return 1;
    }
    if b != 0 {
        PrintLine("FAIL sum_n empty");
        return 1;
    }
    if c != 42 {
        PrintLine("FAIL call0 ident");
        return 1;
    }
    if d != 7 {
        PrintLine("FAIL id_tt");
        return 1;
    }
    PrintLine("PASS macro_repeat");
    return 0;
 }
@@ -0,0 +1,40 @@
 // Declarative macro! + built-in quote! (session 59)
 // Expands before type-check; $frags splice with call-site hygiene.
 import Std::Io::{PrintLine};
 import Std::String::{String_FromInt};
 macro! twice {
    ($x:expr) => {
        ($x) + ($x)
    }
 }
 macro! add2 {
    ($a:expr, $b:expr) => {
        ($a) + ($b)
    }
 }
 func Main() -> int {
    let a: int = twice!(21);
    let b: int = add2!(10, 32);
    // quote! is a built-in identity expand (call-site graft)
    let c: int = quote!(a + 1);
    PrintLine(String_FromInt(a));
    PrintLine(String_FromInt(b));
    PrintLine(String_FromInt(c));
    if a != 42 {
        PrintLine("FAIL twice");
        return 1;
    }
    if b != 42 {
        PrintLine("FAIL add2");
        return 1;
    }
    if c != 43 {
        PrintLine("FAIL quote");
        return 1;
    }
    PrintLine("PASS macro_twice");
    return 0;
 }
@@ -0,0 +1,73 @@
 // Session 69 — unhygienic binders: `var $name` keeps the call-site identifier
 // (not gensym'd). Hygienic template locals (`acc`) still get unique names.
 import Std::Io::{PrintLine};
 import Std::String::{String_FromInt};
 // Introduce a binder named by the call-site ident; keep that name (unhygienic)
 macro! let_mut {
    ( $name:ident, $init:literal ) => {
        var $name: int = $init;
        $name = $name + 1;
        $name
    }
 }
 // Hygienic local `acc` must not collide across two expansions
 macro! double_acc {
    ( $start:literal ) => {
        var acc: int = $start;
        acc = acc + acc;
        acc
    }
 }
 // Mixed: unhygienic $name + hygienic scratch
 macro! bump_named {
    ( $name:ident ) => {
        var $name: int = 0;
        var scratch: int = 1;
        $name = $name + scratch;
        $name
    }
 }
 func Main() -> int {
    // Unhygienic: binder becomes `counter` inside the expansion block
    let a: int = let_mut!(counter, 10);
    // 11
    let b: int = let_mut!(other, 20);
    // 21
    // Hygienic: two expansions with local `acc`
    let c: int = double_acc!(3);
    let d: int = double_acc!(5);
    // 6, 10
    let e: int = bump_named!(n);
    // 1
    PrintLine(String_FromInt(a));
    PrintLine(String_FromInt(b));
    PrintLine(String_FromInt(c));
    PrintLine(String_FromInt(d));
    PrintLine(String_FromInt(e));
    if a != 11 {
        PrintLine("FAIL let_mut counter");
        return 1;
    }
    if b != 21 {
        PrintLine("FAIL let_mut other");
        return 1;
    }
    if c != 6 {
        PrintLine("FAIL double_acc 3");
        return 1;
    }
    if d != 10 {
        PrintLine("FAIL double_acc 5");
        return 1;
    }
    if e != 1 {
        PrintLine("FAIL bump_named");
        return 1;
    }
    PrintLine("PASS macro_unhygienic");
    return 0;
 }
@@ -0,0 +1,63 @@
 // Session 68 — partial field moves out of @[Drop] parents
 // `return bag.items` / `let x = bag.items` must skip Bag_Drop (no double-free).
 // Non-droppable fields (`bag.tag`) do not mark the parent moved.
 import Std::Io::{PrintLine};
 import Std::Array::{Array, Array_New, Array_Push, Array_Len, Array_Get};
 import Std::String::{String_FromInt, String_Concat};
 import Std::Test::{Test_AssertTrue, Test_Pass};
@[Drop]
 struct Bag {
    items: Array<int>,
    tag: int
 }
 func Bag_Drop(self: *Bag) {
    Array_Drop<int>(&self.items);
 }
 // Move droppable field out via return
 func TakeItems() -> Array<int> {
    var items: Array<int> = Array_New<int>(4);
    Array_Push<int>(&items, 42);
    let bag: Bag = Bag { items: items, tag: 7 };
    return bag.items;
 }
 // Move droppable field via let; read non-droppable tag after
 func PeekTagAndTake() -> int {
    var items: Array<int> = Array_New<int>(2);
    Array_Push<int>(&items, 1);
    let bag: Bag = Bag { items: items, tag: 99 };
    let moved: Array<int> = bag.items;
    let t: int = bag.tag;
    discard Array_Len<int>(&moved);
    return t;
 }
 // Whole-struct return still moves bag (existing path)
 func MakeBag() -> Bag {
    var items: Array<int> = Array_New<int>(2);
    Array_Push<int>(&items, 10);
    Array_Push<int>(&items, 20);
    let bag: Bag = Bag { items: items, tag: 3 };
    return bag;
 }
 func Main() -> int {
    let taken: Array<int> = TakeItems();
    Test_AssertTrue(Array_Len<int>(&taken) == 1);
    Test_AssertTrue(Array_Get<int>(&taken, 0) == 42);
    let tag: int = PeekTagAndTake();
    Test_AssertTrue(tag == 99);
    let b: Bag = MakeBag();
    Test_AssertTrue(Array_Len<int>(&b.items) == 2);
    Test_AssertTrue(Array_Get<int>(&b.items, 0) == 10);
    Test_AssertTrue(b.tag == 3);
    PrintLine(String_Concat("ok=", String_FromInt(tag as int64)));
    Test_Pass("move_field_partial");
    return 0;
 }
@@ -0,0 +1,58 @@
 // C.4 — @[Release] zero-cost path vs @[Checked]
 // Default / Release: free; Checked: catches double-mut and dangling returns.
 import Std::Io::{PrintLine, PrintInt};
 import Std::Test::{Test_AssertEqInt, Test_Pass};
 // Tier 1 — unchecked (default)
 func UncheckedInc(p: *int) {
    *p = *p + 1;
 }
 // Tier 2 — borrow checked API surface
@[Checked]
 func SafeInc(p: &mut int) {
    *p = *p + 1;
 }
@[Checked]
 func SafeGet(p: &int) -> int {
    return *p;
 }
 // Tier 3 — explicit zero-cost hot path (Release wins over Checked)
@[Checked]
@[Release]
 func HotInc(p: &mut int) {
    // Would be fine either way; attribute documents "no checker cost here"
    *p = *p + 1;
 }
@[Release]
 func HotDangle() -> &int {
    // Allowed: Release disables dangling-return checks
    var x: int = 99;
    return &x;
 }
 func Main() -> int {
    var n: int = 10;
    UncheckedInc(&n);
    Test_AssertEqInt(n, 11);
    SafeInc(&n);
    Test_AssertEqInt(n, 12);
    HotInc(&n);
    Test_AssertEqInt(n, 13);
    let v: int = SafeGet(&n);
    Test_AssertEqInt(v, 13);
    // HotDangle is only used to prove Release compiles; do not dereference
    discard HotDangle();
    PrintInt(n);
    PrintLine("");
    Test_Pass("ownership_release");
    return 0;
 }
@@ -1478,6 +1478,15 @@ const char* bux_getenv(const char* name) {
    return val ? val : "";
 }
 /* Extra cc/ld flags for host. --build-id is GNU ld only (Apple ld rejects it). */
 const char* bux_cc_ld_stable(void) {
 #if defined(__linux__)
    return " -Wl,--build-id=none";
 #else
    return "";
 #endif
 }
 int bux_setenv(const char* name, const char* value) {
    if (!name || !value) return -1;
    return setenv(name, value, 1);
@@ -127,6 +127,7 @@ module Ast {
    const ekAwait: int = 25;
    const ekStringInterp: int = 26;
    const ekClosure: int = 27;
    const ekMacroCall: int = 28;   // name!(args) — expanded before sema
    struct ExprList {
        expr: *Expr,
@@ -218,6 +219,7 @@ module Ast {
    const skDecl: int = 11;
    const skDefer: int = 12;
    const skSwitch: int = 13;
    const skMacroRep: int = 14;   // $( stmts… )* in macro templates
    struct ElseIf {
        line: uint32;
@@ -265,6 +267,7 @@ module Ast {
    const dkTypeAlias: int = 9;
    const dkExternFunc: int = 10;
    const dkExternVar: int = 11;
    const dkMacro: int = 12;       // macro! name { rules }; rules in childDecl1
    struct Param {
        line: uint32;
@@ -113,25 +113,64 @@ module CBackend {
        return name;
    }
-    /// Mark droppable locals moved by-value (struct fields / nested).
+    /// True when a C type name owns heap / has auto-Drop (not primitives).
    func CBE_IsDroppableTypeName(tn: String) -> bool {
        if tn == null as String || String_Eq(tn, "") { return false; }
        if String_Eq(tn, "void") || String_Eq(tn, "int") || String_Eq(tn, "bool") {
            return false;
        }
        if String_Eq(tn, "int64") || String_Eq(tn, "uint") || String_Eq(tn, "uint64") {
            return false;
        }
        if String_Eq(tn, "float") || String_Eq(tn, "float64") || String_Eq(tn, "char8") {
            return false;
        }
        if String_Eq(tn, "String") || String_Eq(tn, "cstr") { return false; }
        // Array_int, Map_*, user @[Drop] structs (Bag, Token, …)
        return true;
    }
    /// Mark droppable locals moved by-value (struct fields / nested / partial field).
    /// `valueTypeHint`: when non-empty (e.g. function return type), used to decide
    /// whether a field access is an ownership move (`return bag.items` vs `return bag.tag`).
    func CBE_MarkMovedFromNode(cbe: *CEmitter, node: *HirNode) {
        CBE_MarkMovedFromNodeHint(cbe, node, "");
    }
    func CBE_MarkMovedFromNodeHint(cbe: *CEmitter, node: *HirNode, valueTypeHint: String) {
        if node == null as *HirNode { return; }
        if node.kind == hVar {
            CBE_AddMoved(cbe, node.strValue);
            return;
        }
        // Partial field move: only when the *value* type is droppable
        if node.kind == hFieldPtr || node.kind == hFieldAccess {
            var vty: String = valueTypeHint;
            if String_Eq(vty, "") {
                vty = node.typeName;
            }
            // Field HIR often stores the *base* struct typeName — prefer hint
            if CBE_IsDroppableTypeName(vty) {
                // Walk to base local (hVar / load / nested)
                CBE_MarkMovedFromNodeHint(cbe, node.child1, "");
            }
            return;
        }
        if node.kind == hLoad {
            CBE_MarkMovedFromNodeHint(cbe, node.child1, valueTypeHint);
            return;
        }
        if node.kind == hStructInit {
            var field: *HirNode = node.child1;
            while field != null as *HirNode {
-                CBE_MarkMovedFromNode(cbe, field.child1);
+                CBE_MarkMovedFromNodeHint(cbe, field.child1, "");
                field = field.child3;
            }
            return;
        }
        if node.kind == hTupleInit {
-            // child1/child2 + linked extras if any
+            CBE_MarkMovedFromNodeHint(cbe, node.child1, "");
-            CBE_MarkMovedFromNode(cbe, node.child1);
+            CBE_MarkMovedFromNodeHint(cbe, node.child2, "");
            CBE_MarkMovedFromNode(cbe, node.child2);
            return;
        }
    }
@@ -375,13 +414,16 @@ module CBackend {
            return;
        }
-        // Binary
+        // Binary — always parenthesize so C precedence cannot rewrite the AST.
        // Without parens, Mul(Add(a,b), c) emits `a + b * c` (= a+(b*c)) instead of (a+b)*c.
        if kind == hBinary {
            StringBuilder_Append(&cbe.sb, "(");
            CBE_EmitExpr(cbe, node.child1);
            StringBuilder_Append(&cbe.sb, " ");
            StringBuilder_Append(&cbe.sb, CBackend_OpToC(node.intValue));
            StringBuilder_Append(&cbe.sb, " ");
            CBE_EmitExpr(cbe, node.child2);
            StringBuilder_Append(&cbe.sb, ")");
            return;
        }
@@ -494,9 +536,15 @@ module CBackend {
        // (Emitting Drop before the value used to use-after-drop on `return a.id`.)
        if kind == hReturn {
            CBE_EmitDebugLine(cbe, node);
-            // Track moved variables via return / field-move into returned struct
+            // Track moved variables via return / field-move into returned struct.
            // Pass currentRetType so `return bag.items` (Array) marks bag, but
            // `return bag.tag` (int) does not.
            if node.child1 != null as *HirNode {
-                CBE_MarkMovedFromNode(cbe, node.child1);
+                var retHint: String = "";
                if cbe.currentRetType != null as String {
                    retHint = cbe.currentRetType;
                }
                CBE_MarkMovedFromNodeHint(cbe, node.child1, retHint);
            }
            if node.child1 != null as *HirNode && cbe.deferCount > 0 {
                // Materialize into a temp so Drop cannot clobber the returned value.
@@ -554,9 +602,13 @@ module CBackend {
        // Store: combine alloca + value into single declaration
        if kind == hStore {
-            // Track moved variables via assignment/let
+            // Track moved variables via assignment/let (incl. partial field rhs)
-            if node.child2 != null as *HirNode && node.child2.kind == hVar {
+            if node.child2 != null as *HirNode {
-                CBE_AddMoved(cbe, node.child2.strValue);
+                if node.child2.kind == hVar {
                    CBE_AddMoved(cbe, node.child2.strValue);
                } else {
                    CBE_MarkMovedFromNode(cbe, node.child2);
                }
            }
            // Reinitialization removes moved status
            if node.child1 != null as *HirNode && node.child1.kind == hVar {
@@ -17,6 +17,7 @@ module Cli {
    extern func bux_system(cmd: String) -> int;
    extern func bux_getenv(name: String) -> String;
    extern func bux_setenv(name: String, value: String) -> int;
    extern func bux_cc_ld_stable() -> String;
    extern func bux_strlen(s: String) -> uint;
    extern func bux_str_slice(s: String, start: uint, len: uint) -> String;
@@ -226,6 +227,25 @@ func Cli_Compile(source: String, sourceName: String, targetTriple: String) -> St
        decl = decl.childDecl2;
    }
    // Phase 2b: declarative macro! / quote! expansion
    PrintLine("  Macro expand...");
    let macEx: *MacroExpander = MacroExpand_ExpandModule(mod);
    if MacroExpand_DiagCount(macEx) > 0 {
        var mi: int = 0;
        while mi < MacroExpand_DiagCount(macEx) {
            let md: MacroDiag = MacroExpand_GetDiag(macEx, mi);
            let diag: Diagnostic = Diagnostic {
                message: md.message,
                line: md.line,
                column: md.column,
                severity: 0,
            };
            Diagnostic_Print(&diag, sourceName);
            mi = mi + 1;
        }
        return "";
    }
    // Phase 3: Semantic analysis
    PrintLine("  Sema...");
    let sema: *Sema = Sema_Analyze(mod);
@@ -340,13 +360,17 @@ func Cli_Build(srcPath: String, outPath: String, targetTriple: String, isRelease
    if !String_Eq(targetTriple, "") {
        StringBuilder_Append(&cmdBuf, "clang ");
        StringBuilder_Append(&cmdBuf, optFlags);
-        StringBuilder_Append(&cmdBuf, " -pthread -Wl,--build-id=none -target ");
+        StringBuilder_Append(&cmdBuf, " -pthread");
        StringBuilder_Append(&cmdBuf, bux_cc_ld_stable());
        StringBuilder_Append(&cmdBuf, " -target ");
        StringBuilder_Append(&cmdBuf, targetTriple);
        StringBuilder_Append(&cmdBuf, " ");
    } else {
        StringBuilder_Append(&cmdBuf, "cc ");
        StringBuilder_Append(&cmdBuf, optFlags);
-        StringBuilder_Append(&cmdBuf, " -pthread -Wl,--build-id=none ");
+        StringBuilder_Append(&cmdBuf, " -pthread");
        StringBuilder_Append(&cmdBuf, bux_cc_ld_stable());
        StringBuilder_Append(&cmdBuf, " ");
    }
    StringBuilder_Append(&cmdBuf, "-o ");
    StringBuilder_Append(&cmdBuf, outPath);
@@ -424,6 +448,24 @@ func Cli_Check(srcPath: String) -> int {
        decl2 = decl2.childDecl2;
    }
    // Phase 2b: macro expand
    let macEx2: *MacroExpander = MacroExpand_ExpandModule(mod);
    if MacroExpand_DiagCount(macEx2) > 0 {
        var mi2: int = 0;
        while mi2 < MacroExpand_DiagCount(macEx2) {
            let md2: MacroDiag = MacroExpand_GetDiag(macEx2, mi2);
            let diag: Diagnostic = Diagnostic {
                message: md2.message,
                line: md2.line,
                column: md2.column,
                severity: 0,
            };
            Diagnostic_Print(&diag, srcPath);
            mi2 = mi2 + 1;
        }
        return 1;
    }
    // Phase 3: Sema
    let sema: *Sema = Sema_Analyze(mod);
    if Sema_HasError(sema) {
@@ -479,6 +521,14 @@ func Cli_CompileSource(source: String, sourceName: String) -> *HirModule {
        return null as *HirModule;
    }
    // Phase 2b: macro expand
    let macEx3: *MacroExpander = MacroExpand_ExpandModule(mod);
    if MacroExpand_DiagCount(macEx3) > 0 {
        Print("Macro errors in ");
        PrintLine(sourceName);
        return null as *HirModule;
    }
    // Phase 3: Semantic analysis
    let sema: *Sema = Sema_Analyze(mod);
    if Sema_HasError(sema) {
@@ -1623,6 +1673,25 @@ func Cli_BuildProject(projectDir: String, targetTriple: String, isRelease: bool)
    PrintInt(merged.itemCount);
    PrintLine(" declarations");
    // Declarative macro! / quote! expansion (before type-check)
    PrintLine("Expanding macros...");
    let macEx: *MacroExpander = MacroExpand_ExpandModule(merged);
    if MacroExpand_DiagCount(macEx) > 0 {
        var mi: int = 0;
        while mi < MacroExpand_DiagCount(macEx) {
            let md: MacroDiag = MacroExpand_GetDiag(macEx, mi);
            let diag: Diagnostic = Diagnostic {
                message: md.message,
                line: md.line,
                column: md.column,
                severity: 0,
            };
            Diagnostic_Print(&diag, "<macro>");
            mi = mi + 1;
        }
        return 1;
    }
    // Semantic analysis
    PrintLine("Running sema...");
    let sema: *Sema = Sema_Analyze(merged);
@@ -1705,13 +1774,17 @@ func Cli_BuildProject(projectDir: String, targetTriple: String, isRelease: bool)
    if !String_Eq(targetTriple, "") {
        StringBuilder_Append(&ccBuf, "clang ");
        StringBuilder_Append(&ccBuf, optFlags2);
-        StringBuilder_Append(&ccBuf, " -pthread -Wl,--build-id=none -target ");
+        StringBuilder_Append(&ccBuf, " -pthread");
        StringBuilder_Append(&ccBuf, bux_cc_ld_stable());
        StringBuilder_Append(&ccBuf, " -target ");
        StringBuilder_Append(&ccBuf, targetTriple);
        StringBuilder_Append(&ccBuf, " ");
    } else {
        StringBuilder_Append(&ccBuf, "cc ");
        StringBuilder_Append(&ccBuf, optFlags2);
-        StringBuilder_Append(&ccBuf, " -pthread -Wl,--build-id=none ");
+        StringBuilder_Append(&ccBuf, " -pthread");
        StringBuilder_Append(&ccBuf, bux_cc_ld_stable());
        StringBuilder_Append(&ccBuf, " ");
    }
    StringBuilder_Append(&ccBuf, "-o ");
    StringBuilder_Append(&ccBuf, outBin);
@@ -282,6 +282,7 @@ module Lexer {
        if String_Eq(text, "async") { return tkAsync; }
        if String_Eq(text, "await") { return tkAwait; }
        if String_Eq(text, "spawn") { return tkSpawn; }
        if String_Eq(text, "macro") { return tkMacro; }
        return tkIdent;
    }
@@ -666,6 +667,19 @@ module Lexer {
            lexEmitToken(lex, tkHash); return;
        }
        // Macro fragment $name, or bare $ for $(…)*
        if c == 36 { // '$'
            if Lex_IsIdentStart(lexPeek(lex, 0)) {
                while !lexIsAtEnd(lex) && Lex_IsIdentChar(lexPeek(lex, 0)) {
                    discard lexAdvance(lex);
                }
                lexEmitToken(lex, tkIdent);
                return;
            }
            lexEmitToken(lex, tkDollar);
            return;
        }
        lexEmitDiag(lex, "unexpected character");
        lexEmitToken(lex, tkUnknown);
    }
@@ -27,6 +27,7 @@ module Parser {
        diagCount: int,
        diags: *ParserDiag,
        structInitAllowed: bool,
        macroTemplateMode: bool,  // allows $(…)* in macro! bodies
    }
    struct ParserDiag {
@@ -1252,11 +1253,81 @@ module Parser {
                continue;
            }
-            // ! (unwrap operator)
+            // ! — macro call name!(args) or unwrap
            if kind == tkBang {
                discard parserAdvance(p);
                let line: uint32 = parserCurToken(p).line;
                let col: uint32 = parserCurToken(p).column;
                if left.kind == ekIdent && parserCheck(p, tkLParen) {
                    discard parserAdvance(p); // (
                    let e: *Expr = parserMakeExpr(ekMacroCall, line, col);
                    e.strValue = left.strValue;
                    var argCount: int = 0;
                    var firstArg: *ExprList = null as *ExprList;
                    var lastArg: *ExprList = null as *ExprList;
                    // Multi-rep groups: m!(a,b; c,d) — lengths encoded in genericCallee
                    var groupLens: String = "";
                    var curGroup: int = 0;
                    var nGroups: int = 0;
                    while !parserCheck(p, tkRParen) && parserPeek(p, 0) != tkEndOfFile {
                        while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                        if parserCheck(p, tkRParen) { break; }
                        // `;` starts a new arg group
                        if parserMatch(p, tkSemicolon) {
                            if String_Eq(groupLens, "") {
                                groupLens = String_FromInt(curGroup as int64);
                            } else {
                                groupLens = String_Concat(groupLens, String_Concat(";", String_FromInt(curGroup as int64)));
                            }
                            nGroups = nGroups + 1;
                            curGroup = 0;
                            while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                            continue;
                        }
                        let argExpr: *Expr = parserParseExpr(p);
                        let argNode: *ExprList = bux_alloc(sizeof(ExprList)) as *ExprList;
                        argNode.expr = argExpr;
                        argNode.next = null as *ExprList;
                        argNode.argName = "";
                        if firstArg == null as *ExprList {
                            firstArg = argNode;
                            lastArg = argNode;
                        } else {
                            lastArg.next = argNode;
                            lastArg = argNode;
                        }
                        argCount = argCount + 1;
                        curGroup = curGroup + 1;
                        while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                        if parserMatch(p, tkComma) {
                            continue;
                        }
                        // allow `;` at loop top; otherwise end of args
                        if !parserCheck(p, tkSemicolon) {
                            break;
                        }
                    }
                    // finalize last group
                    if curGroup > 0 || nGroups == 0 {
                        if String_Eq(groupLens, "") {
                            groupLens = String_FromInt(curGroup as int64);
                        } else {
                            groupLens = String_Concat(groupLens, String_Concat(";", String_FromInt(curGroup as int64)));
                        }
                        nGroups = nGroups + 1;
                    }
                    // single group → empty genericCallee (flat match)
                    if nGroups <= 1 {
                        e.genericCallee = "";
                    } else {
                        e.genericCallee = groupLens;
                    }
                    e.callArgs = firstArg;
                    e.callArgCount = argCount;
                    discard parserExpect(p, tkRParen, "expected ')' to close macro arguments");
                    left = e;
                    continue;
                }
                let e: *Expr = parserMakeExpr(ekUnwrap, line, col);
                e.child1 = left;
                left = e;
@@ -1466,11 +1537,50 @@ module Parser {
    // ---------------------------------------------------------------------------
    func parserParseStmt(p: *Parser) -> *Stmt {
        while parserCheck(p, tkNewLine) {
            discard parserAdvance(p);
        }
        let tok: LexToken = parserCurToken(p);
        let line: uint32 = tok.line;
        let col: uint32 = tok.column;
        let kind: int = tok.kind;
        // Macro template: $( stmts… )*
        if p.macroTemplateMode && kind == tkDollar && parserPeek(p, 1) == tkLParen {
            discard parserAdvance(p); // $
            discard parserAdvance(p); // (
            let body: *Block = bux_alloc(sizeof(Block)) as *Block;
            body.line = line;
            body.column = col;
            body.sourceFile = "";
            body.stmtCount = 0;
            body.firstStmt = null as *Stmt;
            body.lastStmt = null as *Stmt;
            while !parserCheck(p, tkRParen) && parserPeek(p, 0) != tkEndOfFile {
                while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                if parserCheck(p, tkRParen) { break; }
                let inner: *Stmt = parserParseStmt(p);
                if body.firstStmt == null as *Stmt {
                    body.firstStmt = inner;
                    body.lastStmt = inner;
                } else {
                    body.lastStmt.nextStmt = inner;
                    body.lastStmt = inner;
                }
                body.stmtCount = body.stmtCount + 1;
            }
            discard parserExpect(p, tkRParen, "expected ')' to close macro repetition");
            discard parserExpect(p, tkStar, "expected '*' after macro repetition");
            parserMatch(p, tkSemicolon);
            let s: *Stmt = bux_alloc(sizeof(Stmt)) as *Stmt;
            s.kind = skMacroRep;
            s.line = line;
            s.column = col;
            s.refStmtBlock = body;
            s.nextStmt = null as *Stmt;
            return s;
        }
        // let / var
        if kind == tkLet || kind == tkVar {
            let isVar: bool = (kind == tkVar);
@@ -2197,6 +2307,178 @@ module Parser {
    }
    // ---------------------------------------------------------------------------
    // macro! name { ($x:expr, …) => { template } … }
    // ---------------------------------------------------------------------------
    func parserSetMacroFragName(d: *Decl, idx: int, name: String) {
        if idx == 0 { d.param0.name = name; }
        else if idx == 1 { d.param1.name = name; }
        else if idx == 2 { d.param2.name = name; }
        else if idx == 3 { d.param3.name = name; }
        else if idx == 4 { d.param4.name = name; }
        else if idx == 5 { d.param5.name = name; }
        else if idx == 6 { d.param6.name = name; }
        else if idx == 7 { d.param7.name = name; }
        else if idx == 8 { d.param8.name = name; }
    }
    func parserParseMacroDecl(p: *Parser, isPublic: bool) -> *Decl {
        let line: uint32 = parserCurToken(p).line;
        let col: uint32 = parserCurToken(p).column;
        discard parserExpect(p, tkMacro, "expected 'macro'");
        discard parserExpect(p, tkBang, "expected '!' after macro");
        let nameTok: LexToken = parserExpect(p, tkIdent, "expected macro name");
        while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
        discard parserExpect(p, tkLBrace, "expected '{' to start macro body");
        let d: *Decl = bux_alloc(sizeof(Decl)) as *Decl;
        d.kind = dkMacro;
        d.line = line;
        d.column = col;
        d.isPublic = isPublic;
        d.strValue = nameTok.text;
        d.childDecl1 = null as *Decl;
        d.childDecl2 = null as *Decl;
        var firstRule: *Decl = null as *Decl;
        var lastRule: *Decl = null as *Decl;
        var ruleCount: int = 0;
        while !parserCheck(p, tkRBrace) && parserPeek(p, 0) != tkEndOfFile {
            while parserCheck(p, tkNewLine) || parserCheck(p, tkSemicolon) {
                discard parserAdvance(p);
            }
            if parserCheck(p, tkRBrace) { break; }
            let rline: uint32 = parserCurToken(p).line;
            let rcol: uint32 = parserCurToken(p).column;
            discard parserExpect(p, tkLParen, "expected '(' to start macro pattern");
            let rule: *Decl = bux_alloc(sizeof(Decl)) as *Decl;
            rule.kind = dkMacro;
            rule.line = rline;
            rule.column = rcol;
            rule.strValue = "";
            rule.paramCount = 0;
            rule.childDecl2 = null as *Decl;
            // useNames encodes: "expr" | "ident" | "tt" | "rep:expr," | "rep:expr+expr," (compound)
            // Multiple pattern elements joined by `;`  → multi-rep groups at call site
            var kindsEnc: String = "";
            while !parserCheck(p, tkRParen) && parserPeek(p, 0) != tkEndOfFile {
                while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                if parserCheck(p, tkRParen) { break; }
                if parserMatch(p, tkSemicolon) { continue; }
                // $( $a:kind , $b:kind ),*
                if parserCheck(p, tkDollar) && parserPeek(p, 1) == tkLParen {
                    discard parserAdvance(p); // $
                    discard parserAdvance(p); // (
                    var repNames: String = "";
                    var repKinds: String = "";
                    var nIn: int = 0;
                    while !parserCheck(p, tkRParen) && parserPeek(p, 0) != tkEndOfFile {
                        while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                        if parserCheck(p, tkRParen) { break; }
                        let fragTok: LexToken = parserExpect(p, tkIdent, "expected $name fragment");
                        if !String_StartsWith(fragTok.text, "$") {
                            parserEmitDiag(p, fragTok.line, fragTok.column, "macro fragment must start with '$'");
                        }
                        discard parserExpect(p, tkColon, "expected ':' after fragment name");
                        let kindTok: LexToken = parserExpect(p, tkIdent, "expected fragment kind");
                        var kname: String = kindTok.text;
                        if String_Eq(kname, "lit") { kname = "literal"; }
                        if !(String_Eq(kname, "expr") || String_Eq(kname, "ident") || String_Eq(kname, "tt")
                            || String_Eq(kname, "literal") || String_Eq(kname, "block")) {
                            kname = "expr";
                        }
                        if nIn == 0 {
                            repNames = fragTok.text;
                            repKinds = kname;
                        } else {
                            repNames = String_Concat(repNames, String_Concat("+", fragTok.text));
                            repKinds = String_Concat(repKinds, String_Concat("+", kname));
                        }
                        if rule.paramCount < 9 {
                            parserSetMacroFragName(rule, rule.paramCount, fragTok.text);
                            rule.paramCount = rule.paramCount + 1;
                        }
                        nIn = nIn + 1;
                        while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                        if !parserMatch(p, tkComma) { break; }
                    }
                    discard parserExpect(p, tkRParen, "expected ')' after repeated fragment");
                    var sep: String = "";
                    if parserMatch(p, tkComma) { sep = ","; }
                    discard parserExpect(p, tkStar, "expected '*' after macro repetition");
                    let enc: String = String_Concat("rep:", String_Concat(repKinds, sep));
                    // mark compound count via leading digit in typeParam0 of rule (hack: use isDrop)
                    if rule.paramCount > 0 {
                        // store chunk size on last param via isVariadic false; use methodCount as chunk
                        // Encode: kindsEnc entry includes chunk after @
                        let enc2: String = String_Concat(enc, String_Concat("@", String_FromInt(nIn)));
                        if String_Eq(kindsEnc, "") { kindsEnc = enc2; }
                        else { kindsEnc = String_Concat(kindsEnc, String_Concat(";", enc2)); }
                    }
                    while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                    if parserMatch(p, tkSemicolon) { continue; }
                    if parserMatch(p, tkComma) { continue; }
                    break;
                } else {
                    let fragTok: LexToken = parserExpect(p, tkIdent, "expected $name fragment");
                    if !String_StartsWith(fragTok.text, "$") {
                        parserEmitDiag(p, fragTok.line, fragTok.column, "macro fragment must start with '$'");
                    }
                    discard parserExpect(p, tkColon, "expected ':' after fragment name");
                    let kindTok: LexToken = parserExpect(p, tkIdent, "expected fragment kind");
                    var kname: String = kindTok.text;
                    if String_Eq(kname, "lit") { kname = "literal"; }
                    if !(String_Eq(kname, "expr") || String_Eq(kname, "ident") || String_Eq(kname, "tt")
                        || String_Eq(kname, "literal") || String_Eq(kname, "block")) {
                        kname = "expr";
                    }
                    if rule.paramCount < 9 {
                        parserSetMacroFragName(rule, rule.paramCount, fragTok.text);
                        rule.paramCount = rule.paramCount + 1;
                    }
                    if String_Eq(kindsEnc, "") { kindsEnc = kname; }
                    else { kindsEnc = String_Concat(kindsEnc, String_Concat(";", kname)); }
                    while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
                    if parserMatch(p, tkComma) { continue; }
                    if parserMatch(p, tkSemicolon) { continue; }
                    break;
                }
            }
            rule.useNames = kindsEnc;
            discard parserExpect(p, tkRParen, "expected ')' to close macro pattern");
            while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
            discard parserExpect(p, tkFatArrow, "expected '=>' after macro pattern");
            while parserCheck(p, tkNewLine) { discard parserAdvance(p); }
            let savedTpl: bool = p.macroTemplateMode;
            p.macroTemplateMode = true;
            rule.refBody = parserParseBlock(p);
            p.macroTemplateMode = savedTpl;
            if firstRule == null as *Decl {
                firstRule = rule;
                lastRule = rule;
            } else {
                lastRule.childDecl2 = rule;
                lastRule = rule;
            }
            ruleCount = ruleCount + 1;
            while parserCheck(p, tkNewLine) || parserCheck(p, tkComma) || parserCheck(p, tkSemicolon) {
                discard parserAdvance(p);
            }
        }
        discard parserExpect(p, tkRBrace, "expected '}' to close macro");
        d.childDecl1 = firstRule;
        d.methodCount = ruleCount;
        if ruleCount == 0 {
            parserEmitDiag(p, line, col, "macro has no rules");
        }
        return d;
    }
    // Top-level declaration
    // ---------------------------------------------------------------------------
@@ -2207,11 +2489,15 @@ module Parser {
        }
        let isPublic: bool = parserMatch(p, tkPub);
-        // Parse @[Checked] / @[Drop] / @[Release] attribute
+        // Parse stacked @[Checked] / @[Drop] / @[Release] attributes
        var isChecked: int = 0;
        var isDrop: int = 0;
        var isRelease: int = 0;
-        if parserCheck(p, tkAt) {
+        while true {
            while parserCheck(p, tkNewLine) || parserCheck(p, tkSemicolon) {
                discard parserAdvance(p);
            }
            if !parserCheck(p, tkAt) { break; }
            discard parserAdvance(p); // @
            if parserCheck(p, tkLBracket) {
                discard parserAdvance(p); // [
@@ -2232,10 +2518,9 @@ module Parser {
                    discard parserAdvance(p); // ]
                }
            }
-            // Skip newlines after attribute before the declaration
+        }
-            while parserCheck(p, tkNewLine) || parserCheck(p, tkSemicolon) {
+        while parserCheck(p, tkNewLine) || parserCheck(p, tkSemicolon) {
-                discard parserAdvance(p);
+            discard parserAdvance(p);
            }
        }
        let kind: int = parserPeek(p, 0);
@@ -2270,6 +2555,7 @@ module Parser {
        if kind == tkImport { return parserParseImportDecl(p, isPublic); }
        if kind == tkExtern { return parserParseExternDecl(p, isPublic); }
        if kind == tkInterface { return parserParseInterfaceDecl(p, isPublic); }
        if kind == tkMacro { return parserParseMacroDecl(p, isPublic); }
        if kind == tkExtend {
            discard parserAdvance(p);
@@ -2396,6 +2682,7 @@ module Parser {
        p.tokenCount = tokenCount;
        p.pos = 0;
        p.structInitAllowed = true;
        p.macroTemplateMode = false;
        let diagBuf: *ParserDiag = bux_alloc(256 as uint * sizeof(ParserDiag)) as *ParserDiag;
        p.diags = diagBuf;
        p.diagCount = 0;
@@ -1202,16 +1202,34 @@ module Sema {
        }
        // Block expression (boolValue = true means unsafe block)
        // Value is the last skExpr (macro! templates and `{ e }` as expr).
        // Check stmts inside a child scope and return last expr type WITHOUT
        // re-checking outside that scope (locals must stay visible).
        if kind == ekBlock {
            if expr.refBlock != null as *Block {
                let prevChecked: bool = sema.checkedFunc;
                if expr.boolValue {
                    let prevChecked: bool = sema.checkedFunc;
                    sema.checkedFunc = false;
                    Sema_CheckBlock(sema, expr.refBlock);
                    sema.checkedFunc = prevChecked;
                } else {
                    Sema_CheckBlock(sema, expr.refBlock);
                }
                var blockScope: Scope = Scope_NewChild(sema.scope);
                let prevScope: *Scope = sema.scope;
                sema.scope = &blockScope;
                var lastType: int = tyVoid;
                var blkWalk: *Stmt = expr.refBlock.firstStmt;
                while blkWalk != null as *Stmt {
                    Sema_CheckStmt(sema, blkWalk);
                    if blkWalk.kind == skExpr && blkWalk.child1 != null as *Expr {
                        // CheckStmt already typed the expr; re-read via CheckExpr in-scope
                        lastType = Sema_CheckExpr(sema, blkWalk.child1);
                        if blkWalk.child1.refType != null as *TypeExpr {
                            expr.refType = blkWalk.child1.refType;
                        }
                    }
                    blkWalk = blkWalk.nextStmt;
                }
                sema.scope = prevScope;
                sema.checkedFunc = prevChecked;
                return lastType;
            }
            return tyVoid;
        }
@@ -1424,6 +1442,8 @@ module Sema {
            sym.refType = null as *TypeExpr;
            if stmt.refStmtType != null as *TypeExpr {
                sym.refType = stmt.refStmtType;
                // Prefer annotation typeKind (block inits previously left tyVoid)
                sym.typeKind = Sema_ResolveType(sema, stmt.refStmtType);
                if stmt.refStmtType.kind == tekPointer && stmt.refStmtType.pointerPointee != null as *TypeExpr {
                    sym.typeName = String_Concat(stmt.refStmtType.pointerPointee.typeName, "*");
                } else {
@@ -2329,13 +2349,13 @@ module Sema {
                    s.currentRetType = tyVoid;
                }
-                // Enable borrow checking for @[Checked] functions
+                // @[Checked] enables borrow checks; @[Release] forces zero-cost (C.4)
                let wasChecked: bool = s.checkedFunc;
                s.checkedFunc = decl.isChecked != 0;
                let wasRelease: bool = s.releaseFunc;
                s.releaseFunc = decl.isRelease != 0;
                s.checkedFunc = (decl.isChecked != 0) && !s.releaseFunc;
                s.movedCount = 0;
-                // C.1: lifetime elision before walking the body
+                // C.1: lifetime elision before walking the body (no-op if not checked)
                Sema_ApplyLifetimeElision(s, decl);
                // Check body statements
@@ -147,6 +147,10 @@ module Token {
    // Lifetime parameter token: 'a, 'b, ... (not a char literal)
    const tkLifetime: int = 111;
    // Declarative macros (session 60 — selfhost parity)
    const tkMacro: int = 112;
    const tkDollar: int = 113;  // bare $ for $(…)*
    // ---------------------------------------------------------------------------
    // Token struct
    // ---------------------------------------------------------------------------
@@ -229,6 +233,7 @@ module Token {
        if String_Eq(text, "async") { return tkAsync; }
        if String_Eq(text, "await") { return tkAwait; }
        if String_Eq(text, "spawn") { return tkSpawn; }
        if String_Eq(text, "macro") { return tkMacro; }
        if String_Eq(text, "true") { return tkBoolLiteral; }
        if String_Eq(text, "false") { return tkBoolLiteral; }
        return tkIdent;
@@ -318,6 +323,8 @@ module Token {
        if kind == tkAmpAmp { return "&&"; }
        if kind == tkPipePipe { return "||"; }
        if kind == tkBang { return "!"; }
        if kind == tkMacro { return "macro"; }
        if kind == tkDollar { return "$"; }
        if kind == tkEq { return "=="; }
        if kind == tkNe { return "!="; }
        if kind == tkLt { return "<"; }
@@ -371,3 +371,46 @@ func Main() -> int {
 }
 """)
    check(not res.hasErrors)
  test "@[Release] alone disables checks (zero-cost path)":
    let res = checkSource("""
@[Release]
 func Dangle() -> &int {
  var x: int = 1;
  return &x;
 }
 func Main() -> int {
  return 0;
 }
 """)
    check(not res.hasErrors)
  test "@[Checked] @[Release] — Release wins, no use-after-move error":
    let res = checkSource("""
@[Checked]
@[Release]
 func Consume(s: own String) {
  // move then use — allowed because Release disables checker
  let t: own String = s;
  let u: own String = s;
 }
 func Main() -> int {
  return 0;
 }
 """)
    check(not res.hasErrors)
  test "@[Checked] still errors without Release":
    let res = checkSource("""
@[Checked]
 func Bad() -> &int {
  var x: int = 1;
  return &x;
 }
 func Main() -> int {
  return 0;
 }
 """)
    check(res.hasErrors)
    check(res.diagnostics[0].message.contains("local") or
          res.diagnostics[0].message.contains("reference"))
@@ -17,6 +17,8 @@
 # v0.13.0: textDocument/implementation (interface → types / methods).
 # v0.14.0: workspace-wide import path index (no open-doc required).
 # v0.15.0: type hierarchy (prepare / supertypes / subtypes via extend for).
 # v0.16.0: workspace type-impl index — hierarchy works for closed multi-file
 #          docs even when `extend T for I` has no methods (no open required).
 import std/[json, os, strutils, streams, tables, osproc, sequtils, sets]
 import lexer, parser, ast, sema, types, scope, source_location
@@ -154,6 +156,10 @@ var
  ## Import paths by file URI (from scanWorkspace + open docs) — v0.14
  ## Each entry is a full path like @["Std", "Io"] (not open-doc dependent).
  workspaceImportPaths = initTable[string, seq[seq[string]]]()
  ## Type ↔ interface relations from `extend Type for Iface` (v0.16).
  ## Keyed by file URI so re-analyze replaces stale entries (open or closed).
  ## Does not require methods in the extend body (unlike workspaceImpls).
  workspaceTypeRels = initTable[string, seq[tuple[typeName, iface: string, line: int]]]()
  cachedStdlibDir = ""
  cachedStdlibDecls: seq[Decl] = @[]
  stdlibLoaded = false
@@ -170,6 +176,11 @@ proc registerWorkspaceImports(uri: string, segs: seq[PathSegInfo]) =
    paths.add(s.path)
  workspaceImportPaths[uri] = paths
 proc registerWorkspaceTypeRels(uri: string, impls: seq[tuple[typeName, iface: string, line: int]]) =
  ## Replace type↔interface relations for this URI (from analyzeFile `impls`).
  ## Empty impls clears prior entries so deleted extends disappear from hierarchy.
  workspaceTypeRels[uri] = impls
 proc getDoc(uri: string): DocumentState =
  if not documents.hasKey(uri):
    documents[uri] = DocumentState(uri: uri)
@@ -630,6 +641,8 @@ proc analyzeFile(path: string, content: string): DocumentState =
  # Always refresh workspace import index for this URI (empty clears stale paths)
  registerWorkspaceImports(result.uri, result.importPaths)
  # Type hierarchy / implementation: keep extend-for relations for closed files
  registerWorkspaceTypeRels(result.uri, result.impls)
 # ---------------------------------------------------------------------------
 # Real sema types for hover
@@ -2631,8 +2644,30 @@ proc collectImplementorFuncs(iface, meth: string): seq[FuncSym] =
 proc collectTypeImplementorLocs(iface: string): seq[JsonNode] =
  ## Locations of types that `extend Type for iface`.
  ## Uses workspace type-rel index so closed multi-file works without methods.
  result = @[]
  var seen = initHashSet[string]()
  # 1) Workspace type relations
  for uri, rels in workspaceTypeRels.pairs:
    for impl in rels:
      if impl.iface != iface: continue
      let key = uri & "#" & impl.typeName
      if seen.contains(key): continue
      seen.incl(key)
      if workspaceSymbols.hasKey(impl.typeName):
        let ws = workspaceSymbols[impl.typeName]
        result.add(locationJson(ws.uri, ws.info.line, ws.info.col, impl.typeName.len))
      elif documents.hasKey(uri):
        let doc = documents[uri]
        ensureAnalyzed(doc)
        if doc.symbols.hasKey(impl.typeName):
          let info = doc.symbols[impl.typeName]
          result.add(locationJson(uri, info.line, info.col, impl.typeName.len))
        else:
          result.add(locationJson(uri, impl.line, 0, max(1, impl.typeName.len)))
      else:
        result.add(locationJson(uri, impl.line, 0, max(1, impl.typeName.len)))
  # 2) Open docs
  for uri, doc in documents.pairs:
    ensureAnalyzed(doc)
    for impl in doc.impls:
@@ -2644,9 +2679,8 @@ proc collectTypeImplementorLocs(iface: string): seq[JsonNode] =
        let info = doc.symbols[impl.typeName]
        result.add(locationJson(uri, info.line, info.col, impl.typeName.len))
      else:
        # Fall back to the `extend` line
        result.add(locationJson(uri, impl.line, 0, max(1, impl.typeName.len)))
-  # Derive types from workspaceImpls (Iface.Method → typeName)
+  # 3) Fallback: workspaceImpls (Iface.Method → typeName)
  for wkey, impls in workspaceImpls.pairs:
    if not wkey.startsWith(iface & "."): continue
    for impl in impls:
@@ -2990,8 +3024,22 @@ proc typeHierarchyItemSynthetic(uri: string, name: string, kind: string, line: i
 proc collectSubtypeItems(iface: string): seq[JsonNode] =
  ## Types that `extend Type for iface`.
  ## Prefer workspace type-rel index (closed multi-file; empty extend bodies OK).
  result = @[]
  var seen = initHashSet[string]()
  # 1) Workspace type relations (scan + every analyzeFile) — no open required
  for uri, rels in workspaceTypeRels.pairs:
    for impl in rels:
      if impl.iface != iface: continue
      let key = uri & "#" & impl.typeName
      if seen.contains(key): continue
      seen.incl(key)
      let (ok, u, info) = resolveTypeSymbol(impl.typeName, uri)
      if ok:
        result.add(typeHierarchyItem(u, impl.typeName, info))
      else:
        result.add(typeHierarchyItemSynthetic(uri, impl.typeName, "struct", impl.line))
  # 2) Open docs (live buffer may differ from last register)
  for uri, doc in documents.pairs:
    ensureAnalyzed(doc)
    for impl in doc.impls:
@@ -3004,7 +3052,7 @@ proc collectSubtypeItems(iface: string): seq[JsonNode] =
        result.add(typeHierarchyItem(u, impl.typeName, info))
      else:
        result.add(typeHierarchyItemSynthetic(uri, impl.typeName, "struct", impl.line))
-  # workspaceImpls: "Iface.Method" → (uri, typeName, meth)
+  # 3) Fallback: workspaceImpls "Iface.Method" (methods in extend body)
  for wkey, impls in workspaceImpls.pairs:
    if not wkey.startsWith(iface & "."): continue
    for impl in impls:
@@ -3021,6 +3069,18 @@ proc collectSupertypeItems(typeName: string): seq[JsonNode] =
  ## Interfaces that `typeName` implements via `extend typeName for I`.
  result = @[]
  var seen = initHashSet[string]()
  # 1) Workspace type relations (closed multi-file)
  for uri, rels in workspaceTypeRels.pairs:
    for impl in rels:
      if impl.typeName != typeName: continue
      if seen.contains(impl.iface): continue
      seen.incl(impl.iface)
      let (ok, u, info) = resolveTypeSymbol(impl.iface, uri)
      if ok:
        result.add(typeHierarchyItem(u, impl.iface, info))
      else:
        result.add(typeHierarchyItemSynthetic(uri, impl.iface, "interface", impl.line))
  # 2) Open docs
  for uri, doc in documents.pairs:
    ensureAnalyzed(doc)
    for impl in doc.impls:
@@ -3032,6 +3092,7 @@ proc collectSupertypeItems(typeName: string): seq[JsonNode] =
        result.add(typeHierarchyItem(u, impl.iface, info))
      else:
        result.add(typeHierarchyItemSynthetic(uri, impl.iface, "interface", impl.line))
  # 3) Fallback: method-based workspaceImpls
  for wkey, impls in workspaceImpls.pairs:
    for impl in impls:
      if impl.typeName != typeName: continue
@@ -3137,7 +3198,7 @@ proc handleMessage(stream: FileStream, msg: JsonNode) =
        "implementationProvider": true,
        "typeHierarchyProvider": true
      },
-      "serverInfo": {"name": "bux-lsp", "version": "0.15.0"}
+      "serverInfo": {"name": "bux-lsp", "version": "0.16.0"}
    })
    if paramsNode.hasKey("rootPath") and paramsNode["rootPath"].kind != JNull:
      rootPath = paramsNode["rootPath"].getStr()
@@ -0,0 +1,81 @@
 #!/usr/bin/env bash
 # Golden-ish smoke: field-move + partial field-move Drop emission.
 # Ensures C for TakeItems has no Bag_Drop (would double-free returned Array).
 set -euo pipefail
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 BUXC="${BUXC:-$ROOT/buxc}"
 export BUX_STDLIB="${BUX_STDLIB:-$ROOT/lib}"
 unset BUX_DEBUG_FILE || true
 if [[ ! -x "$BUXC" ]]; then
  (cd "$ROOT" && make build)
 fi
 TMP=$(mktemp -d)
 trap 'rm -rf "$TMP"' EXIT
 # --- move_field (whole local into field) ---
 echo "=== smoke: move_field ==="
 mkdir -p "$TMP/mf/src"
 cp -a "$ROOT/rt" "$TMP/mf/"
 cat > "$TMP/mf/bux.toml" <<'EOF'
 [Package]
 Name    = "move_field"
 Version = "0.1.0"
 Type    = "bin"
 [Build]
 Output = "Bin"
 EOF
 cp "$ROOT/examples/move_field.bux" "$TMP/mf/src/Main.bux"
 (cd "$TMP/mf" && "$BUXC" run .)
 # Only the MakeBox *body* (not prototypes / other functions)
 if sed -n '/^Box MakeBox(void) {/,/^}/p' "$TMP/mf/build/main.c" | grep -q 'Array_Drop\|Bag_Drop'; then
  echo "error: MakeBox still drops moved Array" >&2
  sed -n '/^Box MakeBox(void) {/,/^}/p' "$TMP/mf/build/main.c"
  exit 1
 fi
 echo "  move_field: PASS (run + no Array_Drop of moved local)"
 # --- partial field move ---
 echo "=== smoke: move_field_partial ==="
 mkdir -p "$TMP/mp/src"
 cp -a "$ROOT/rt" "$TMP/mp/"
 cat > "$TMP/mp/bux.toml" <<'EOF'
 [Package]
 Name    = "move_field_partial"
 Version = "0.1.0"
 Type    = "bin"
 [Build]
 Output = "Bin"
 EOF
 cp "$ROOT/examples/move_field_partial.bux" "$TMP/mp/src/Main.bux"
 (cd "$TMP/mp" && "$BUXC" run .)
 # TakeItems must not call Bag_Drop after moving bag.items out
 if sed -n '/^Array_int TakeItems/,/^}/p' "$TMP/mp/build/main.c" | grep -q 'Bag_Drop'; then
  echo "error: TakeItems still Bag_Drops after partial field move" >&2
  sed -n '/^Array_int TakeItems/,/^}/p' "$TMP/mp/build/main.c"
  exit 1
 fi
 echo "  move_field_partial: PASS (run + TakeItems has no Bag_Drop)"
 # --- early return Drop counts ---
 echo "=== smoke: drop_early_return ==="
 mkdir -p "$TMP/de/src"
 cp -a "$ROOT/rt" "$TMP/de/"
 cat > "$TMP/de/bux.toml" <<'EOF'
 [Package]
 Name    = "drop_early_return"
 Version = "0.1.0"
 Type    = "bin"
 [Build]
 Output = "Bin"
 EOF
 cp "$ROOT/examples/drop_early_return.bux" "$TMP/de/src/Main.bux"
 out=$(cd "$TMP/de" && "$BUXC" run .)
 echo "$out" | grep -q 'PASS'
 echo "  drop_early_return: PASS"
 echo "PASS: smoke_drop_move (field-move + partial + early-return)"
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Smoke: type hierarchy prepare / subtypes / supertypes (bux-lsp 0.15)
+# Smoke: type hierarchy prepare / subtypes / supertypes (single-file; bux-lsp 0.15+)
 set -euo pipefail
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 LSP="$ROOT/tools/bux-lsp"
@@ -62,8 +62,8 @@ URI="file://$TMP/Main.bux"
  rpc '{"jsonrpc":"2.0","method":"exit","params":null}'
 } | "$LSP" 2>/dev/null | tr '\r' '\n' > "$TMP/out.txt"
-if ! grep -q '0.15.0' "$TMP/out.txt"; then
+if ! grep -qE '0\.(15|16)\.0' "$TMP/out.txt"; then
-  echo "WARN: version not 0.15.0"
+  echo "WARN: unexpected LSP version (expected 0.15+)"
 fi
 if ! grep -q 'typeHierarchyProvider' "$TMP/out.txt"; then
@@ -120,5 +120,5 @@ if 'Drawable' not in snames:
    sys.exit(1)
 print(f'  supertypes Circle → {sorted(snames)}')
-print('PASS: LSP type hierarchy (0.15)')
+print('PASS: LSP type hierarchy (single-file)')
 PY
@@ -0,0 +1,158 @@
 #!/usr/bin/env bash
 # Smoke: type hierarchy across closed multi-file workspace (bux-lsp 0.16)
 # Only Main.bux is opened. Drawable.bux + Shapes.bux stay closed (scanWorkspace).
 # Empty `extend T for I {}` bodies — no methods — must still populate hierarchy
 # via workspaceTypeRels (not method-only workspaceImpls).
 set -euo pipefail
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 LSP="$ROOT/tools/bux-lsp"
 TMP=$(mktemp -d)
 trap 'rm -rf "$TMP"' EXIT
 if [[ ! -x "$LSP" ]]; then
  (cd "$ROOT" && make lsp >/dev/null)
 fi
 cat > "$TMP/Drawable.bux" <<'EOF'
 interface Drawable {
    func Draw(self: &Self);
 }
 interface Named {
 }
 EOF
 cat > "$TMP/Shapes.bux" <<'EOF'
 struct Circle {
    radius: int;
 }
 struct Square {
    side: int;
 }
 // Empty extend bodies — no methods; relation must still be indexed
 extend Circle for Drawable {
 }
 extend Square for Drawable {
 }
 extend Circle for Named {
 }
 EOF
 # Only this file is opened. Types are closed on disk.
 cat > "$TMP/Main.bux" <<'EOF'
 func Use(d: Drawable, c: Circle) -> int {
    return 0;
 }
 func Main() -> int {
    return 0;
 }
 EOF
 rpc() {
  local body="$1"
  local len
  len=$(printf '%s' "$body" | wc -c)
  printf 'Content-Length: %s\r\n\r\n%s' "$len" "$body"
 }
 CONTENT_JSON=$(python3 -c 'import json,sys; print(json.dumps(open(sys.argv[1]).read()))' "$TMP/Main.bux")
 URI="file://$TMP/Main.bux"
 # Drawable at col 12, Circle at col 25 in "func Use(d: Drawable, c: Circle)..."
 DRAW_COL=12
 CIRC_COL=25
 {
  rpc '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{},"rootUri":"file://'"$TMP"'"}}'
  rpc '{"jsonrpc":"2.0","method":"initialized","params":{}}'
  rpc '{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"'"$URI"'","languageId":"bux","version":1,"text":'"$CONTENT_JSON"'}}}'
  # prepare on Drawable (type annotation; def in closed Drawable.bux)
  rpc '{"jsonrpc":"2.0","id":2,"method":"textDocument/prepareTypeHierarchy","params":{"textDocument":{"uri":"'"$URI"'"},"position":{"line":0,"character":'"$DRAW_COL"'}}}'
  # subtypes of Drawable → Circle + Square (closed Shapes.bux, empty extends)
  rpc '{"jsonrpc":"2.0","id":3,"method":"typeHierarchy/subtypes","params":{"item":{"name":"Drawable","kind":11,"uri":"file://'"$TMP"'/Drawable.bux","data":"Drawable","range":{"start":{"line":0,"character":0},"end":{"line":0,"character":8}},"selectionRange":{"start":{"line":0,"character":0},"end":{"line":0,"character":8}}}}}'
  # prepare on Circle
  rpc '{"jsonrpc":"2.0","id":4,"method":"textDocument/prepareTypeHierarchy","params":{"textDocument":{"uri":"'"$URI"'"},"position":{"line":0,"character":'"$CIRC_COL"'}}}'
  # supertypes of Circle → Drawable + Named
  rpc '{"jsonrpc":"2.0","id":5,"method":"typeHierarchy/supertypes","params":{"item":{"name":"Circle","kind":23,"uri":"file://'"$TMP"'/Shapes.bux","data":"Circle","range":{"start":{"line":0,"character":0},"end":{"line":0,"character":6}},"selectionRange":{"start":{"line":0,"character":0},"end":{"line":0,"character":6}}}}}'
  # subtypes of Named → Circle only
  rpc '{"jsonrpc":"2.0","id":6,"method":"typeHierarchy/subtypes","params":{"item":{"name":"Named","kind":11,"uri":"file://'"$TMP"'/Drawable.bux","data":"Named","range":{"start":{"line":0,"character":0},"end":{"line":0,"character":5}},"selectionRange":{"start":{"line":0,"character":0},"end":{"line":0,"character":5}}}}}'
  rpc '{"jsonrpc":"2.0","id":7,"method":"shutdown","params":null}'
  rpc '{"jsonrpc":"2.0","method":"exit","params":null}'
 } | "$LSP" 2>/dev/null | tr '\r' '\n' > "$TMP/out.txt"
 if ! grep -q '0.16.0' "$TMP/out.txt"; then
  echo "WARN: version not 0.16.0"
 fi
 python3 - <<'PY' "$TMP/out.txt" "$TMP"
 import json, sys, re
 raw = open(sys.argv[1]).read()
 tmp = sys.argv[2]
 got = {}
 for p in re.split(r'Content-Length:\s*\d+\s*', raw):
    p = p.strip()
    if not p.startswith('{'):
        continue
    try:
        j = json.loads(p)
    except Exception:
        continue
    if 'id' in j and 'result' in j:
        got[j['id']] = j['result']
 def names(r):
    if not isinstance(r, list):
        return set()
    return {x.get('name') for x in r if isinstance(x, dict)}
 def uris(r):
    if not isinstance(r, list):
        return set()
    return {x.get('uri', '') for x in r if isinstance(x, dict)}
 r2 = got.get(2) or []
 if 'Drawable' not in names(r2):
    print('FAIL: prepare Drawable (closed def) missing')
    print(got.get(2))
    sys.exit(1)
 # Prefer closed file URI for the type item
 u2 = uris(r2)
 if not any('Drawable.bux' in u for u in u2):
    print(f'FAIL: prepare Drawable should point at Drawable.bux, got {u2}')
    sys.exit(1)
 print('  prepare Drawable → closed Drawable.bux: OK')
 r3 = got.get(3) or []
 n3 = names(r3)
 if 'Circle' not in n3 or 'Square' not in n3:
    print(f'FAIL: subtypes Drawable expected Circle+Square (empty extends), got {n3}')
    print(json.dumps(r3, indent=2)[:800])
    sys.exit(1)
 u3 = uris(r3)
 if not any('Shapes.bux' in u for u in u3):
    print(f'FAIL: subtypes should reference closed Shapes.bux, got {u3}')
    sys.exit(1)
 print(f'  subtypes Drawable → {sorted(n3)} (closed, empty extend): OK')
 r4 = got.get(4) or []
 if 'Circle' not in names(r4):
    print('FAIL: prepare Circle missing')
    print(got.get(4))
    sys.exit(1)
 print('  prepare Circle → closed Shapes.bux: OK')
 r5 = got.get(5) or []
 n5 = names(r5)
 if 'Drawable' not in n5 or 'Named' not in n5:
    print(f'FAIL: supertypes Circle expected Drawable+Named, got {n5}')
    print(json.dumps(r5, indent=2)[:800])
    sys.exit(1)
 print(f'  supertypes Circle → {sorted(n5)}: OK')
 r6 = got.get(6) or []
 n6 = names(r6)
 if n6 != {'Circle'}:
    print(f'FAIL: subtypes Named expected only Circle, got {n6}')
    sys.exit(1)
 print(f'  subtypes Named → {sorted(n6)}: OK')
 print('PASS: LSP type hierarchy workspace index (0.16)')
 PY
@@ -166,4 +166,89 @@ if ! echo "$main_body" | grep -vE '#line 1 "' | grep -qE '#line [0-9]+ ".*Main\.
 fi
 echo "  Expr/Stmt sourceFile: PASS (Main stmts → Main.bux only)"
-echo "PASS: selfhost smoke (move_field + multi-file #line + HirNode/Expr sourceFile)"
+# ---------------------------------------------------------------------------
 # 5) Binary op parentheses — C precedence must not rewrite Mul(Add,c)
 #    Without parens selfhost emitted `a + b * c` → 7 instead of (a+b)*c → 9
 # ---------------------------------------------------------------------------
 echo "=== selfhost: binary op parentheses (C precedence) ==="
 PREC="$TMP/c_precedence"
 mkdir -p "$PREC/src"
 cp -a "$ROOT/rt" "$PREC/"
 cat > "$PREC/bux.toml" <<'EOF'
 [Package]
 Name    = "c_precedence"
 Version = "0.1.0"
 Type    = "bin"
 [Build]
 Output = "Bin"
 EOF
 cp "$ROOT/examples/c_precedence.bux" "$PREC/src/Main.bux"
 (cd "$PREC" && "$BUXC2" project .)
 prec_out=$("$PREC/build/c_precedence")
 echo "$prec_out" | tee "$TMP/prec.out"
 grep -q 'PASS c_precedence' "$TMP/prec.out"
 # Generated C must parenthesize the sum before multiply
 if ! grep -A3 '^int MulSum' "$PREC/build/main.c" | grep -qE '\(a \+ b\) \* c|\(\(a \+ b\) \* c\)'; then
  echo "error: MulSum C lacks parentheses around a+b before *c" >&2
  grep -n -A5 '^int MulSum' "$PREC/build/main.c" | head -20
  exit 1
 fi
 if ! grep -A3 '^int SubDiv' "$PREC/build/main.c" | grep -qE '\(a - b\) / c|\(\(a - b\) / c\)'; then
  echo "error: SubDiv C lacks parentheses around a-b before /c" >&2
  grep -n -A5 '^int SubDiv' "$PREC/build/main.c" | head -20
  exit 1
 fi
 echo "  binary parens: PASS (run 9/3/6/7 + C has (a + b) * c)"
 # ---------------------------------------------------------------------------
 # 6) declarative macro! / quote! expand (session 60 selfhost parity)
 # ---------------------------------------------------------------------------
 echo "=== selfhost: macro! expand ==="
 MAC="$TMP/macro_twice"
 mkdir -p "$MAC/src"
 cp -a "$ROOT/rt" "$MAC/"
 cat > "$MAC/bux.toml" <<'EOF'
 [Package]
 Name    = "macro_twice"
 Version = "0.1.0"
 Type    = "bin"
 [Build]
 Output = "Bin"
 EOF
 cp "$ROOT/examples/macro_twice.bux" "$MAC/src/Main.bux"
 (cd "$MAC" && "$BUXC2" project .)
 mac_out=$("$MAC/build/macro_twice")
 echo "$mac_out" | tee "$TMP/mac.out"
 grep -q 'PASS macro_twice' "$TMP/mac.out"
 grep -q '42' "$TMP/mac.out"
 echo "  macro!: PASS (twice/add2/quote → 42/42/43)"
 # ---------------------------------------------------------------------------
 # 7) multi-rep / compound zip / nested template $(…)* (session 63)
 # ---------------------------------------------------------------------------
 echo "=== selfhost: macro_nested multi-rep ==="
 MACN="$TMP/macro_nested"
 mkdir -p "$MACN/src"
 cp -a "$ROOT/rt" "$MACN/"
 cat > "$MACN/bux.toml" <<'EOF'
 [Package]
 Name    = "macro_nested"
 Version = "0.1.0"
 Type    = "bin"
 [Build]
 Output = "Bin"
 EOF
 cp "$ROOT/examples/macro_nested.bux" "$MACN/src/Main.bux"
 (cd "$MACN" && "$BUXC2" project .)
 macn_out=$("$MACN/build/macro_nested")
 echo "$macn_out" | tee "$TMP/macn.out"
 grep -q 'PASS macro_nested' "$TMP/macn.out"
 grep -q '33' "$TMP/macn.out"
 grep -q '63' "$TMP/macn.out"
 echo "  macro_nested: PASS (add_pairs/sum_groups/double_each/named_sum)"
 echo "PASS: selfhost smoke (move_field + multi-file #line + HirNode/Expr sourceFile + binop parens + macro! + multi-rep)"