@calcit/procs 0.13.44 → 0.13.46

package/editing-history/20260825-2121-macro-parameter-diagnostics.md

@@ -0,0 +1,10 @@
+# Macro parameter diagnostics and coverage
+
+- Added one shared parameter-shape model for required, optional, and rest bindings, including malformed marker sequences. Both preprocessing and `analyze check-types` now use the same comparison and stable diagnostic codes.
+- Preserved ordinary function compatibility: existing function schemas describe fixed arity without separately encoding the `?` marker. Strict optional-shape comparison is enabled for macros, while ordinary functions compare total fixed arity.
+- Macro schema-shape mismatches remain staged during ecosystem migration. `analyze check-types` reports them by default; location-aware preprocessing warnings can be enabled with `CALCIT_WARN_MACRO_SCHEMA_SHAPE=1` and use `W_MACRO_SCHEMA_PARAM_SHAPE`.
+- Corrected whole-`Dynamic` macro coverage from `Full` to `None`; explicitly typed macro schemas with Dynamic argument/result slots remain `Partial`. Explicit `:: Dynamic` now remains distinct from an omitted schema across binary serialization and reports `W_MACRO_SCHEMA_DYNAMIC`, while omission reports `W_SCHEMA_MISSING`.
+- Same-command coverage baseline:
+  - Calcit core: overall `full/partial/none` changed from `420/107/18` to `405/107/33`; macros changed from `18/61/0` to `3/61/15`.
+  - Respo `respo.core`: overall changed from `12/53/1` to `7/53/6`; its five whole-`Dynamic` macros changed from `Full` to `None`.
+- External regression used latest Respo 0.16.86 and Recollect 0.0.34. Respo required rebuilding `.calcit/modules` with `caps --ci` because its local `js-ffi` view was still at 0.1.9 despite `deps.cirru` declaring 0.1.10.

package/editing-history/20260825-2138-keep-malformed-macro-params-hard.md

@@ -0,0 +1,5 @@
+# Keep malformed macro parameters as hard errors
+
+- Review identified that the staged macro-schema partition was too broad and also included `E_DEF_PARAM_SHAPE`.
+- Only schema compatibility mismatches (`E_SCHEMA_REQUIRED_ARGS`, `E_SCHEMA_OPTIONAL_ARGS`, and `E_SCHEMA_REST_ARGS`) are now staged during ecosystem migration.
+- Malformed source parameter sequences and schema-kind mismatches remain hard preprocessing errors.

package/editing-history/20260825-2311-macro-capability-review-followup.md

@@ -0,0 +1,10 @@
+# Macro capability review follow-up
+
+- Keep the canonical strict Macro signature example complete by serializing an
+  explicit empty `:capabilities` set.
+- Treat mutable BufList construction and mutation as `:mutable-state` during
+  macro expansion.
+- Validate capability leaves as colon-prefixed tags before general Cirru EDN
+  parsing, preserving a stable schema-specific error instead of accepting a
+  write that cannot round-trip.
+- Verified with the macro capability and macro schema unit-test groups.

package/editing-history/20260825-2312-macro-expansion-metrics.md

@@ -0,0 +1,11 @@
+# Macro expansion metrics baseline
+
+- Added opt-in `--macro-metrics` JSON-on-stderr instrumentation for expansion
+  counts, exclusive evaluator/post-preprocess time, general evaluator fallback,
+  and cache outcome reasons.
+- Nested macro phases pause parent timers so aggregate costs are not inflated by
+  recursive inclusive timing.
+- Release-mode baselines on the Calcit test snapshot and latest Respo identify
+  post-expansion processing and common structural macros as the next targets.
+- This is the instrumentation checkpoint for issue #436; it deliberately does
+  not add the typed Macro IR or pure expansion cache yet.

package/editing-history/20260825-2337-macro-query-and-capability-scope.md

@@ -0,0 +1,11 @@
+# Macro query and capability scope follow-up
+
+- Preserve strict Macro contracts in `query schema`, `query context`, and JSON
+  output instead of degrading them through ordinary type serialization.
+- Serialize an explicit empty `:capabilities` set for every strict/pure Macro;
+  legacy signatures retain their compatibility representation.
+- Limit a strict macro's capability context to evaluation of its own body.
+  Post-preprocessing an emitted expansion may invoke a separate nested macro,
+  whose effects must not be charged to the outer emitter.
+- Added query regression coverage and validated the boundary with the migrated
+  core `fn` macro emitting bodies that contain platform-sensitive legacy macros.

package/editing-history/20260825-2338-core-structural-macro-contracts.md

@@ -0,0 +1,10 @@
+# Core structural macro contracts
+
+- Migrated `let`, `fn`, `and`, `cond`, and `do` from whole-Dynamic legacy
+  schemas to strict, compile-time-pure phase contracts.
+- Kept expansion values as `Expr<Dynamic>` where the result depends on user
+  code, while enforcing list-shaped binding/argument/condition syntax.
+- Canonicalized strict Macro storage with explicit empty capability sets and
+  added snapshot assertions so the migrated set cannot silently regress.
+- The Calcit test snapshot now exposes 895 strict/pure expansion candidates in
+  the measured run (up from 4), while preserving all 2,432 expansions.

package/editing-history/20260825-2356-delayed-macro-metrics-review.md

@@ -0,0 +1,5 @@
+# Delayed macro metrics review
+
+- Clarified that `cacheHits` and `cacheInvalidations` are reserved report fields until the expansion cache is implemented.
+- Made the metrics report unit test operate on local state, avoiding interference with global opt-in metrics state when Rust tests run in parallel.
+- Kept production collection behavior unchanged by extracting small state-local recording and serialization helpers.

package/editing-history/202608252220-phase-aware-macro-signatures.md

@@ -0,0 +1,35 @@
+# Phase-aware macro signatures
+
+Implemented roadmap issue #434 after the parameter-shape diagnostics from
+#433/#438 landed.
+
+- Added a dedicated `MacroSignature` model instead of representing macros as
+  runtime `CalcitFnTypeAnnotation` values.
+- Split raw inputs into `Syntax`, `SyntaxSymbol`, `SyntaxList`, and `Expr<T>`;
+  split expansion results into `Expr<T>`, `Definition<T>`, and `Declarations`.
+- Added required, optional, rest, generic, where-bound, and feature metadata.
+- Preserved old `Macro {:args ... :return ...}` snapshots as explicit legacy,
+  non-strict signatures; the ordinary Fn parser rejects strict macro fields.
+- Attached signatures to materialized `CalcitMacro` values, typed macro-body
+  locals at syntax phase, and added separate call-input and expansion-result
+  diagnostics with source locations and macro stacks.
+- Updated snapshot, detailed snapshot, weak-type, and coverage paths so the new
+  model survives all formats and contributes accurate coverage.
+- Migrated core `%{}?` to `SyntaxSymbol + & SyntaxList -> Expr<Struct>` and
+  documented Respo `defstyle` as the declaration-output case study.
+
+Validation performed:
+
+- `cargo fmt`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test`
+- `yarn compile`
+- `yarn check-all`
+- `yarn check-agent-interface`
+- `calcit docs check-md --entry src/cirru/calcit-core.cirru docs/MacroSignature.md`
+- latest Respo main: 27/27 tests and 126/126 documentation blocks
+- latest Recollect main: 9/9 Calcit tests plus JS tests
+
+External regressions used globally installed Calcit 0.13.44 and refreshed
+`@calcit/procs` 0.13.44; stale local 0.13.27 packages were replaced before the
+final run.

package/editing-history/202608252249-macro-compile-time-capabilities.md

@@ -0,0 +1,27 @@
+# Macro compile-time capabilities
+
+Issue #435 adds an enforceable effect boundary around strict macro execution.
+The capability policy is centralized in `runner::macro_capability` and remains
+active through ordinary helper calls by using a scoped evaluator context.
+
+Strict `MacroSignature` values now serialize a dedicated `:capabilities`
+hashset. Pure expansion needs no declaration. Environment, filesystem,
+platform, clock, mutable-state, and dynamic-eval reads/actions may be declared;
+filesystem writes, process control, and host FFI are classified but always
+rejected. Legacy macro signatures stay compatible, but their effects remain
+unknown and they are not eligible for future pure-expansion caching.
+
+The evaluator checks builtin procedures, state/dynamic-eval syntax, native
+methods, registered procedures, and raw host code. Missing declarations use
+`E_MACRO_CAPABILITY_MISSING`; forbidden operations use
+`E_MACRO_CAPABILITY_DISALLOWED`. Both preserve the macro call location and
+helper chain. Quoted code that performs an effect later at runtime remains a
+pure expansion. Macro diagnostics also reuse the raw call-head location instead
+of the locationless resolved import, preserving no-argument call sites.
+
+Validation covered formatting, clippy, all Rust and CLI tests, native/JS/IR/WASM
+integration, agent-interface checks, and the macro-signature documentation.
+Latest Respo passed 27 tests and 126 documentation blocks. Latest Recollect
+passed 9 native tests plus JS and WASM regressions. Its production build still
+reports the existing Respo DOM FFI and `:unit`/`:nil` warning baseline; neither
+external repository was modified.

package/editing-history/20260826-0007-assertion-macro-contracts.md

@@ -0,0 +1,8 @@
+# Assertion macro contracts
+
+- Migrated the three `calcit.core` assertion macros and five `calcit.test` helpers to strict, pure phase-aware contracts.
+- Kept input values as `Expr<Dynamic>` because equality and truthiness intentionally accept heterogeneous runtime values.
+- Declared precise expansion results: `Expr<Unit>` for assertion helpers and `Expr<Bool>` for `throws?`.
+- Added the missing successful `&unit` branch to `assert=` so its implementation matches its long-standing Unit contract.
+- Added snapshot coverage and exercised definition-attached tests plus public examples.
+- On `calcit/test.cirru`, strict/pure macro candidates increased from 895 to 1,666 while total expansions stayed at 2,432.

package/editing-history/20260826-0023-assertion-macro-review.md

@@ -0,0 +1,4 @@
+# Assertion macro review
+
+- Strengthened the real Snapshot inventory test to assert the exact required input count for each `calcit.test` assertion helper.
+- Kept the original history timestamp because the commit was created at `2026-08-26 00:13:33 +0800`; the review bot compared against the previous UTC date.

package/editing-history/20260826-0038-control-flow-macro-contracts.md

@@ -0,0 +1,9 @@
+# Control-flow macro contracts
+
+- Migrated `or`, `either`, `when`, `when-not`, `if-not`, `if-let`, and `when-let` to strict, pure phase-aware contracts.
+- Preserved expression-level Dynamic boundaries where branch value types intentionally vary, while declaring `when-let` as `Expr<Option<Dynamic>>`.
+- Corrected the `or false nil` example to expect the final falsey value (`nil`) and clarified that behavior in its documentation.
+- Fixed strict macro body parameter typing: `SyntaxList` is represented as a list, `SyntaxSymbol` as a symbol, and rest bindings as lists of their declared syntax element type.
+- Added regression coverage for strict macro body parameter representations and the real core Snapshot inventory.
+- Increased strict macro coverage in `calcit/test.cirru` from 1666 to 1805 of 2432 expansions.
+- Verified the release compiler against Respo `be8141e` (27 tests and check-only JS) and Recollect `6c235d0` (9 native tests plus JS/Node tests).

package/editing-history/20260826-0100-review-exact-control-flow-contracts.md

@@ -0,0 +1,5 @@
+# Exact control-flow contract regression checks
+
+- Strengthened the core Snapshot inventory to assert each migrated control-flow macro's exact required, optional, and rest syntax contracts.
+- Asserted exact expansion types, including `when-let` as `Expr<Option<Dynamic>>` and the remaining macros as `Expr<Dynamic>`.
+- Documented the strict macro body type helpers added by the original change.

package/editing-history/20260826-0120-pattern-macro-contracts.md

@@ -0,0 +1,8 @@
+# Pattern-matching macro contracts
+
+- Migrated `tag-match`, `list-match`, `struct-match`, `case`, and their internal expansion helpers to strict, compile-time-pure macro contracts.
+- Kept branch bodies as `SyntaxList`; retained `list-match`'s heterogeneous public argument sequence as an intentional `Syntax` rest boundary while typing its internal helper exactly.
+- Corrected the pre-existing `tag-match` example expectation from `got:hello` to `hello:got`, matching `str x |:got`.
+- Added exact Snapshot assertions for required, optional, rest, capability, and expansion contracts across both `calcit.core` and `calcit.internal`.
+- Increased strict macro coverage in `calcit/test.cirru` from 1805 to 1949 of 2432 expansions.
+- Verified all repository gates plus Respo `be8141e`, Recollect `6c235d0`, and js-ffi `25869b6`; js-ffi dependencies were reinstalled from its 0.13.44 lockfile before Node/browser contract tests.

package/editing-history/20260826-0133-collection-macro-contracts.md

@@ -0,0 +1,9 @@
+# Collection macro contracts
+
+- Migrated `{}`, `%{}`, and `{,}` to strict, compile-time-pure macro contracts.
+- Declared map literal expansions as `Expr<Map<Dynamic, Dynamic>>` and struct literal expansion as `Expr<Struct>`.
+- Kept pair-oriented inputs as `SyntaxList` and the flat comma-filtering `{,}` body as an intentional raw `Syntax` rest boundary.
+- Corrected the pre-existing `%{}` example to use field pairs `(:x 1)` and `(:y 2)` rather than list-constructor calls that introduced extra fields.
+- Added exact Snapshot assertions for each macro's input and expansion contracts.
+- Increased strict macro coverage in `calcit/test.cirru` from 1949 to 2133 of 2432 expansions.
+- Verified all repository gates plus Respo `be8141e`, Recollect `6c235d0`, and js-ffi `25869b6` with the current compiler.

package/editing-history/20260826-0152-definition-macro-contracts.md

@@ -0,0 +1,25 @@
+# Definition-value macro contracts
+
+## Changes
+
+- Migrated `def` to a pure phase-aware macro contract with a symbol declaration name and an explicit dynamic expression boundary.
+- Migrated `deftrait`, `defstruct`, `defimpl`, and `defenum` to strict syntax-input contracts with precise `Trait`, `StructDef`, `Impl`, and `EnumDef` expression outputs.
+- Kept symbol/tag compatibility for data-definition names by using unrestricted syntax for those positions; method and field forms use list syntax where the macro requires pair/list forms.
+- Added Snapshot assertions for required, optional, rest, capability, and expansion fields so serialization regressions cannot silently weaken these contracts.
+
+## Semantic finding
+
+Although these macros generate top-level definition values, the core `def` macro is consumed before the outer expansion-result check. Their observable expansion contract is therefore `Expr<T>`, not `Definition<T>`. Using `Definition<T>` fails against the real core corpus because the checked form is already `&trait::new`, `&struct-def:new`, `&impl::new`, or `&enum-def:new`.
+
+## Validation
+
+- Core strict macro expansions: `2133/2432` -> `2341/2432`; legacy bypasses: `299` -> `91`.
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `yarn compile`
+- `cargo test`
+- `yarn check-all`
+- `yarn check-agent-interface`
+- Respo `be8141e`: 27 definition-attached tests and JS check-only passed.
+- Recollect `6c235d0`: 9 unit tests, JS generation, and Node runtime passed.
+- js-ffi `25869b6`: default/node/browser checks plus Node and browser-node contracts passed.

package/editing-history/20260826-0203-transform-macro-contracts.md

@@ -0,0 +1,28 @@
+# Transform macro contracts
+
+## Changes
+
+- Migrated `->`, `->%`, and `%<-` with phase-aware base/step contracts.
+- Migrated `apply-args` and `flipped` with callable input contracts and explicit dynamic result boundaries.
+- Migrated anonymous function shorthands `\` and `\.` with syntax inputs and callable expression outputs.
+- Migrated `[,]` with arbitrary syntax inputs and a `List<Dynamic>` expression output.
+- Added exact Snapshot assertions for every required, optional, rest, capability, and expansion field.
+
+## Contract notes
+
+- Thread steps in `->` remain unrestricted syntax because the macro deliberately accepts symbol, tag, method, function, and list forms.
+- Calcit's canonical callable schema type is `'Fn`; `'DynFn` is not the public schema spelling.
+- `%<-`, `\`, and `[,]` retain runtime empty-input diagnostics because their implementation uses rest-only parameters and the phase signature mirrors that actual binder shape.
+
+## Validation
+
+- Reachable strict expansions: `2341/2432` -> `2364/2432`; legacy bypasses: `91` -> `68`.
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `yarn compile`
+- `cargo test` (one unrelated parallel feature-policy test flaked once; isolated and full reruns passed)
+- `yarn check-all`
+- `yarn check-agent-interface`
+- Respo `be8141e`: 27 tests and JS check-only passed.
+- Recollect `6c235d0`: 9 tests, JS generation, and Node runtime passed.
+- js-ffi `25869b6`: default/node/browser checks and both runtime contracts passed.

package/editing-history/20260826-0214-binding-update-macro-contracts.md

@@ -0,0 +1,14 @@
+# Binding and update macro contracts
+
+## Changes
+
+- Migrated `let-destruct`, `let-sugar`, `let[]`, `let{}`, and `loop` to phase-aware binding and body contracts.
+- Migrated `struct-with`, `swap!`, and `&doseq` with concrete struct/ref/callable inputs and struct/Unit outputs where proven.
+- Added `assert-type pair 'List` inside `let-sugar` so strict macro-body analysis retains the list evidence already guaranteed by its runtime validation.
+- Added exact Snapshot assertions for all contract fields.
+
+## Validation
+
+- Reachable strict expansions: `2364/2432` -> `2379/2432`; legacy bypasses: `68` -> `53`.
+- Full `cargo fmt`, Clippy, compile, Rust tests, `yarn check-all`, and Agent interface gates passed.
+- Latest Respo `be8141e`, Recollect `6c235d0`, and js-ffi `25869b6` regressions passed.

package/editing-history/20260826-0629-type-observability-macros.md

@@ -0,0 +1,8 @@
+# Type observability macro contracts
+
+- Migrated logging, timing, hygiene, documentation, and debug function-wrapper macros to strict phase-aware signatures.
+- Preserve expression result types for `w-log`, `wo-log`, `with-cpu-time`, and `noted` with a generic `T` contract.
+- Require callable expressions for `call-w-log` and `call-wo-log`, structural symbol/list inputs for function-definition and gensym helpers, and definition-shaped function expansions for `defn-w-log`/`defn-wo-log`.
+- Declare `:platform-read` only for macros that inspect the Calcit running mode while expanding. Runtime logging and `cpu-time` emitted into quoted code do not count as compile-time capabilities.
+- Benchmarked the full macro-contract migration against `3a7afb5e`: both release check-only medians remained about 0.15 seconds across 12 warm runs. Strict/cache-eligible expansion coverage rose from 4 to 2379 before this batch; this batch moves another 8 pure expansions to cache eligibility and classifies 5 platform-dependent expansions honestly.
+- Verified earlier, structured failures for invalid callable/list/ref macro arguments. No expansion cache exists yet, so this work provides visible diagnostics and cache prerequisites rather than a current runtime speedup.

package/editing-history/20260826-0642-type-remaining-match-macros.md

@@ -0,0 +1,7 @@
+# Remaining core match macro contracts
+
+- Migrated `case-default`, `field-match`, and `calcit.internal/&field-match-internal` to strict phase-aware macro signatures.
+- `case-default` now validates both value/default expression inputs and requires every pattern arm to be list-shaped syntax while keeping its branch-dependent output honest as `Expr<Dynamic>`.
+- `field-match` and its recursive helper now require a map expression before expansion, so invalid values fail at the public macro boundary with `E_MACRO_INPUT_EXPR_TYPE` instead of reaching generated runtime assertions.
+- Added snapshot assertions for required inputs, rest-arm syntax, pure capability sets, and expansion categories.
+- The core suite now observes 2392 pure/cache-eligible expansions, 5 explicitly platform-dependent expansions, and only 35 legacy expansions, all of which belong to test helper macros.

package/editing-history/20260826-0654-macro-log-capability.md

@@ -0,0 +1,8 @@
+# Compile-time macro log capability
+
+- Added the opt-in `:log` macro capability for compile-time `echo`, `println`, and `eprintln` calls.
+- Registered procedures remain forbidden host FFI by default; the three platform console aliases are the narrow exception and still require an explicit capability declaration.
+- Documented that quoted runtime logging stays pure while logging actually executed during expansion is observable and therefore cache-ineligible.
+- Added positive, missing-capability, and unrelated-host-procedure tests for the policy plus schema round-trip coverage for `:log`.
+- Migrated the final test helper macros: `inside-eval:`/`inside-js:` declare `:platform-read`, `add-11` declares `:log`, and the hygienic no-log helper remains pure.
+- Macro metrics now report zero legacy bypasses: 2393 pure/cache-eligible expansions and 39 explicitly capability-dependent expansions out of 2432 total. Cache hits remain zero until the planned cache implementation lands.

package/editing-history/20260826-0707-release-01345.md

@@ -0,0 +1,6 @@
+# Release 0.13.45
+
+- Publish the completed phase-aware macro contract migration and compile-time capability policy improvements.
+- Includes strict contracts across the observed core corpus, explicit `:platform-read` and `:log` effects, and zero legacy macro-signature bypasses in `calcit/test.cirru` metrics.
+- Provides the stable compiler version required for Respo's six strict macro contracts, especially `defstyle` compile-time logging.
+- Release validation is based on the merged PR gates plus latest Respo, Recollect, and js-ffi regressions run with the built compiler.

package/editing-history/20260826-0741-finish-core-macro-contracts.md

@@ -0,0 +1,9 @@
+# Finish bundled core macro contracts
+
+- Audited all 86 `defmacro` entries bundled in `calcit.core`, `calcit.internal`, and `calcit.test`, rather than relying only on macros reached by `calcit/test.cirru`.
+- Migrated the remaining 21 legacy schemas, including aliases, Option/Result binding macros, anonymous enums, JS objects, logging helpers, deprecated compatibility macros, and open collection lookup helpers.
+- Kept broad collection payloads explicitly `Dynamic` where list/string/enum/open-data behavior cannot yet be represented safely by one static contract; used concrete `String`, `Enum`, `JsObject`, `Option`, `Result`, `Nil`, and generic identity contracts where the semantics support them.
+- Added a snapshot inventory test that rejects any bundled `defmacro` using a legacy whole-Dynamic schema and records the audited count.
+- Added an exact `js-object` round-trip assertion for its `SyntaxList` input, `JsObject` expansion, and `:js-ffi` backend feature so schema indentation cannot silently drop the feature metadata.
+- Confirmed the existing core corpus remains at 2,393 pure/cache-eligible expansions plus 39 declared-capability expansions, with zero legacy expansions. The migration itself does not implement caching, so it improves diagnostics and cache safety prerequisites without claiming a present speedup.
+- Compared 12 alternating release `--check-only` runs on Respo against the installed 0.13.45 binary: both warm medians were 0.12s. The release binary grew from 9,586,224 to 9,586,256 bytes (+32 bytes), so this final schema pass shows neither a visible speed gain nor a material regression.

package/editing-history/20260826-0843-result-parsing-methods.md

@@ -0,0 +1,7 @@
+# Result-returning parsing methods
+
+- Added `.parse-cirru`, `.parse-cirru-list`, `.parse-cirru-edn`, and `.parse-json` to the core String method bag. Their function-form compatibility entry points are `try-parse-*`.
+- Recoverable parse failures now return nominal `Result` values instead of requiring user code to catch exceptions or interpret nil. CirruQuote/List successes retain their known outer shape; open EDN/JSON payloads deliberately remain Dynamic.
+- Moved detailed Cirru parser diagnostics into `CalcitErr.msg` and removed unconditional stderr printing, so a caught failure retains line/column/nearby-input context.
+- Added definition-attached native tests, native/JS examples, and EDN documentation. Full Calcit gates and latest Respo/Recollect native, JS, docs, and WASM regressions passed after refreshing locked modules and toolchains.
+- A separate narrow typed Macro IR experiment reduced the measured Respo macro-evaluator phase by about 12% but did not produce a stable end-to-end check improvement; it was not landed and the evidence is recorded on issue #436.

package/editing-history/20260826-0847-result-parsing-error-examples.md

@@ -0,0 +1,5 @@
+# Cross-backend parser failure examples
+
+- Added a malformed-input example to each Result-returning String parser method.
+- Native and JavaScript example runners now exercise both `:ok` and caught `:err` paths for Cirru, Cirru-list, Cirru-EDN, and JSON parsing.
+- The JavaScript Cirru-EDN parser still emits its existing parser-library diagnostic while returning the caught Result; this PR preserves compatibility and verifies the Result semantics without claiming that host parser output is fully silent.

package/editing-history/20260826-0850-document-parser-backend-boundary.md

@@ -0,0 +1,4 @@
+# Document parser backend boundary
+
+- Clarified that Result-returning parser methods are currently native/JavaScript APIs.
+- Distinguished a green whole-project WASM regression from support for parser definitions: WASM deliberately skips the unsupported parser/`try` definitions while validating all supported exports.

package/editing-history/20260826-1006-typed-decode-result.md

@@ -0,0 +1,30 @@
+# Typed decode Result syntax
+
+## Summary
+
+- Added `try-parse-cirru-edn-as text TypeExpr` and `try-decode-map-as value TypeExpr`.
+- Decoder graphs are still derived during preprocessing. Invalid or open target types remain compile-time errors.
+- Runtime parse and recursive shape failures now become nominal `Result<T,String>` errors with their structural path intact.
+- Known non-String text inputs are rejected during preprocessing; Dynamic boundaries retain runtime validation.
+- Native and generated JavaScript implement the same Result contract. WASM keeps the existing explicit typed-decoder unsupported boundary.
+
+## Backend consistency
+
+Generated JavaScript `try` handlers previously received a host `Error` object even though native Calcit and the public guide specify a String message. JS codegen now normalizes `Error.message` (or stringifies a non-Error throw) before invoking the handler. The new Result syntaxes use the same normalization, so their `:err` payload is a String on both supported backends.
+
+## Type and performance assessment
+
+The visible benefit is semantic and static: successful expressions infer `Result<T,String>` with the complete target type, malformed input is explicit in control flow, invalid target schemas fail before runtime, and known invalid text arguments are rejected during preprocessing. This slice does not claim a speedup. Decoder work is unchanged and the safe success path additionally constructs one Result value; callers should choose it for recoverable external input rather than throughput.
+
+## Validation
+
+- `cargo fmt`
+- `cargo clippy -- -D warnings`
+- `cargo test` (520 library, 246 CLI, 24 caps, 4 WASM tests)
+- `yarn compile`
+- `yarn check-all` (native, generated JS, IR, WASM, 228 core tests)
+- `yarn check-agent-interface` (17/17)
+- Native and generated-JS attached examples for success, failure, exact type, and String error payload
+- `docs/data/edn.md` 24/24 and `docs/features/error-handling.md` 9/9 markdown blocks
+- Latest Respo main: 27/27 tests and 111/111 documentation blocks
+- Latest Recollect main: 9/9 native tests, generated JS, and required WASM checks

package/editing-history/20260826-1108-pure-macro-expansion-cache.md

@@ -0,0 +1,17 @@
+# Conservative pure macro expansion cache
+
+- Added a watch-mode raw expansion cache for strict macros with no declared
+  compile-time capabilities. Once-mode builds bypass it to avoid cold-build
+  overhead.
+- Keyed entries by stable macro call site, macro runtime identity, phase-aware
+  signature, and exact raw syntax including source locations. Macro/helper
+  reloads recreate the macro identity; signature and input changes have separate
+  invalidation reasons in `--macro-metrics`.
+- Preserved hygiene by recording the per-definition gensym position and only
+  reusing generated-symbol expansions when the sequence still matches. Cache
+  hits advance the counter by the recorded delta.
+- Cached only successfully validated raw expansions. Emitted code is still
+  preprocessed and type-checked on every hit, so this slice cannot reuse stale
+  type/import results and does not claim the higher post-preprocess speedup yet.
+- Kept legacy and capability-bearing macros on the general evaluator with
+  explicit bypass reasons.

package/editing-history/20260826-1149-upgrade-ternary-tree-0021.md

@@ -0,0 +1,20 @@
+# Upgrade ternary-tree to 0.0.21
+
+- Upgraded `im_ternary_tree` from 0.0.20 to 0.0.21. The upstream release
+  removes redundant cloning in owned vector construction and finger-tree
+  updates, and reports substantially faster full iteration and search
+  microbenchmarks.
+- Compared optimized Calcit binaries built from the same source snapshot, with
+  only the ternary-tree version changed. Runs alternated old/new order on Apple
+  arm64 to reduce thermal and background-load drift.
+- Over 30 paired process runs, `--check-only calcit/test.cirru` improved by
+  about 0.83% at the median and the native literal-path benchmark improved by
+  about 0.39%. Over 20 paired macro-metric runs, post-preprocessing improved by
+  about 1.22%, while macro evaluation remained effectively unchanged.
+- Treat the small aggregate gains as evidence of no regression plus a modest
+  end-to-end benefit. Calcit parsing, type analysis, evaluation, and process
+  startup dominate these workloads, so the upstream collection microbenchmark
+  gains are not expected to transfer proportionally to whole-program timings.
+- Revalidated Rust formatting, Clippy with warnings denied, the full Rust test
+  suite, self-hosted compilation, Agent CLI protocol checks, native/JS/IR/WASM
+  integration tests, and collection-path performance smoke tests.

package/editing-history/20260826-1200-nested-macro-gensym-cache.md

@@ -0,0 +1,16 @@
+# Preserve nested macro gensym positions on cache hits
+
+- Fixed pure macro expansion caching so its replay delta contains only gensyms
+  emitted by the cached macro evaluator. The evaluator end position is captured
+  before recursively preprocessing the returned syntax tree.
+- Excluded gensyms emitted by nested macros during post-processing from the
+  outer cache entry. Nested macros still run or replay their own gensym progress
+  when the cached outer syntax is preprocessed, preventing double advancement.
+- Added a regression test that compares miss and hit paths for an outer macro
+  whose output invokes a gensym-producing inner macro, and verifies that the
+  following gensym position is identical.
+- Kept the Calcit package at 0.13.45 in this functional PR. Package versions are
+  updated together in `Cargo.toml` and `package.json` by the separate release
+  commit after the feature PR merges.
+- Validated formatting, Clippy with warnings denied, all 799 Rust tests, and the
+  full native/JS/IR/WASM integration suite through `yarn check-all`.

package/editing-history/20260826-1208-release-01346.md

@@ -0,0 +1,11 @@
+# Release 0.13.46
+
+- Released the completed macro-contract, safe Result parsing/typed decode, and
+  pure macro expansion-cache work accumulated after 0.13.45.
+- Included `im_ternary_tree` 0.0.21, which has a small measured end-to-end
+  improvement in Calcit check/preprocessing workloads without regressions.
+- The macro cache remains a conservative watch-mode-only optimization for
+  strict macros with no compile-time capabilities. Its nested-macro gensym
+  replay is covered by a regression test.
+- Kept Cargo and npm package versions in lockstep at 0.13.46 and refreshed the
+  workspace lockfile before tagging the main branch.

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.13.44",
+    "version": "0.13.46",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.7.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.13.44",
+  "version": "0.13.46",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.7.0",