@calcit/procs 0.13.42 → 0.13.44

package/RFCs/04-15-match-syntax-rfc.md

@@ -127,20 +127,26 @@ missing = all_variants - covered_tags
 
 ## 6. JS 代码生成
 
-生成立即执行函数表达式（IIFE）：
+动态或无法安全重排的 match 保留立即执行函数中的 if-else 链。静态已知 enum 且分支没有重复 tag、wildcard 位于末尾时，预处理器会生成内部 declaration-order branch table；JS codegen 对该形式生成 `switch (tag.idx)`，native evaluator 通过 enum definition 的 variant index 直接选择 slot。这个内部表示不增加用户语法，匿名 enum 和动态边界仍使用兼容路径。
+
+概念上的 JS 输出如下：
 
 ```javascript
 (() => {
   let match_v = <value>;
   let match_t = _$n_tuple_$o_nth(match_v, 0);
-  if (match_t === _kn_ok && _$n_tuple_$o_count(match_v) === 1) {
-    return kwd_$o_success;  // (:ok) :success
-  } else if (match_t === _kn_err && _$n_tuple_$o_count(match_v) === 2) {
-    let msg = _$n_tuple_$o_nth(match_v, 1);
-    return msg;  // (:err msg) msg
-  } else {
-    throw new Error("match: no matching branch for tag");
+  switch (match_t.idx) {
+    case _kn_ok.idx:
+      if (_$n_tuple_$o_count(match_v) === 1) return kwd_$o_success;
+      break;
+    case _kn_err.idx:
+      if (_$n_tuple_$o_count(match_v) === 2) {
+        let msg = _$n_tuple_$o_nth(match_v, 1);
+        return msg;
+      }
+      break;
   }
+  throw new Error("match: no matching branch for tag");
 })()
 ```
 

package/RFCs/04-15-type-directed-optimization-catalog.md

@@ -71,30 +71,33 @@
 
 ---
 
-### P3: `tag-match` 分支整数化 ⬜ 推迟（侵入性大，CalcitTuple 12+ 构造点需改动）
+### P3: 已知 enum 的 `match` 分支索引化 ✅ #422
 
-**问题**: `tag-match` 运行时用 tag 字符串逐一比较（线性扫描分支）。JS codegen 也是 if-else 链。
+**问题**: 原生 `match` 虽然保留了 enum 类型和分支结构，native 运行时仍逐项比较 tag，JS codegen 也输出 if-else 链。旧目录将其写成 `tag-match` 优化，但该宏展开后已经丢失结构；真正可安全优化的是原生 `match`。
 
-**位置**: `src/builtins/syntax.rs` L933-1050（runner），`src/codegen/emit_js.rs` L897-978（JS codegen）。
+**实际方案**:
 
-**方案**:
+- 预处理器仅在 enum 类型已知、tag 不重复、wildcard 位于末尾时，生成内部 declaration-order branch table；
+- native 复用 `CalcitEnumDef` 已有的 tag→variant HashMap，一次查找后直接选择 branch slot；
+- JS 对同一内部表示生成 `switch (tag.idx)`；
+- WASM 继续消费其已有整数 tag，并兼容 branch table 表示；
+- 动态/匿名 enum、重复 tag、early wildcard 保留原始线性表示和语义。
 
-- **Rust 端**: enum 类型已知时预处理阶段把 tag 比较替换为 `variant_index` 的整数比较
-- **JS 端**: emit `switch (tag.idx)` 替代 if-else 链
+没有给 `CalcitEnumValue` 新增字段，也没有增加用户语法，因此避免修改所有 enum 构造和序列化边界。
 
-**收益**: 5+ 分支时 O(n) → O(1)。
+**收益**: native 从 O(branches) 降为平均 O(1) branch selection；JS 由引擎整数 switch 分派。
 
 **影响**: 中 — 状态机、消息路由场景（Cumulo updater dispatcher）明显加速。
 
 ---
 
-### P4: Method dispatch 静态绑定 ⬜ 推迟（复杂度高，待类型覆盖率提高）
+### P4: Method dispatch 静态绑定 ✅ #426
 
 **问题**: `.method obj` 运行时路径：① 匹配 receiver 类型 → ② 查 impl 列表（builtin 还要 evaluate symbol）→ ③ 线性遍历 `impls` 数组找方法名。
 
 **位置**: `src/builtins/meta.rs` L1016-1095，`method_call_impls` 函数。
 
-**方案**: 预处理阶段 receiver 类型和 trait 均已知时，直接解析到 `CalcitFn`/`CalcitProc`，把 `.method obj args` 重写为 `(resolved-fn obj args)`。
+**实际方案**: 预处理阶段 receiver 类型和 impl precedence 已知时，已有的 `try_inline_method_call` 会直接解析到稳定的 top-level callable 或 `CalcitProc`，把 `.method obj args` 重写为 `(resolved-fn obj args)`；Dynamic receiver、无法安全保留 closure 身份的 method entry 继续运行时 dispatch。#426 补齐了静态绑定后的 executable call metadata，使 `.add`、`.multiply`、`.rem` 等 resolved proc 还能进入 typed native number fast path，并把 remainder 纳入该 fast path。runtime 在执行 metadata 前仍校验实际 proc，hot reload 或 host interop 使静态证据过期时退回普通错误路径。
 
 **收益**: 消除 symbol resolution + linear impl search。
 
@@ -118,11 +121,13 @@
 
 ---
 
-### P6: `get-in` / `assoc-in` 静态路径展开
+### P6: `get-in` / `assoc-in` 静态路径展开 ✅ #424
 
 **问题**: `get-in base [:a :b :c]` 是 Calcit 编写的递归函数（`calcit-core.cirru`），每层递归拆列表 + 动态 `get`。
 
-**方案**: 路径是字面量列表且 base 类型已知 Record 时，编译期展开为嵌套 `&record:nth`。`assoc-in` 同理展开为嵌套的 `&record:assoc-at`。
+**方案**: 路径是非空字面量列表，且 base 与每个需要继续遍历的中间 payload 都有非 Dynamic 静态类型时，在预处理阶段展开。`get-in` 的最终 payload 可以是 Dynamic，展开结果仍为对应的 `Option`；`assoc-in` 第一阶段只接受全 Map 路径，并额外要求最终 payload 非 Dynamic，再展开为逐层 `&map:contains?`、`&map:get`、`&map:assoc`。Dynamic collection hop、混合容器、空路径以及任何进入 Struct 的路径继续调用原函数。`get-in` 展开保留 `%some` / `%none`、nil 短路与逐层 Struct guard。
+
+旧方案中沿 Record/Struct 字段展开的设想已经废弃。公开 `get-in` / `assoc-in` 明确不遍历 Struct；必填字段继续使用 `(:field value)` 与直接 `assoc`，不能借性能优化绕开名义类型检查。
 
 **收益**: 消除递归、list 分解、运行时字段查找。
 
@@ -162,9 +167,10 @@
 | 4    | P2   | `0e705f1` | NativeRecordWithAt 批量索引化           | Record 批量更新加速（fibo 不涉及） |
 | 5    | P7   | `fa325c6` | if 常量折叠                             | 宏展开场景受益                     |
 | -    | 额外 | `7c04880` | runtime def resolution 去重复 RwLock 读 | 微优化                             |
+| 6    | P3   | #422      | typed `match` branch table + JS switch  | enum dispatcher / state machine    |
+| 7    | P6   | #424      | typed literal collection path expansion | nested map/list lookup and map update |
+| 8    | P4   | #426      | static method calls retain native op metadata | typed remainder loop ~11% faster |
 
 ### 待定
 
-- **P3**: tag-match 整数化 — 推迟，CalcitTuple 12+ 构造点需改动，侵入性大
-- **P4**: Method dispatch 静态绑定 — 推迟，实现复杂度高
-- **P6**: get-in/assoc-in 静态路径展开 — 未开始，视实际瓶颈决定
+- 在最新 Respo/Recollect 工作负载上继续 profiling；后续项目以实测热点为准，不再预设广泛 unboxing 或关闭 Dynamic 边界。

package/RFCs/08-05-systematic-nil-reduction-rfc.md

@@ -25,7 +25,7 @@
 - 名称以 `&` 开头的 raw primitive 属于 semver-private 实现细节，允许在内部使用 nullable 表示，但不得直接挂入公开方法表；
 - 已生成 JS bundle 引用的 npm runtime export 属于 codegen ABI：typed wrapper/raw proc 改名时必须保留兼容 export，并由 runtime identity test 覆盖；类型系统负责阻断重新编译的旧 FFI 源码，但不能替代旧 bundle 的装载兼容性；
 - 新增查询 API 不得先返回 nil、再在后续版本改成 Option。类型和所有后端实现必须在首次发布时一致；
-- `analyze weak-types --only code-nil --intent unresolved,declared-optional` 必须对 core 返回零结果；
+- `analyze weak-types --only code-nil --intent unresolved,declared-unit,declared-optional` 必须对 core 返回零结果；
 - 以后若要改变这些名义返回类型，只能作为独立的非 nil 设计变更处理，不能再以“清理遗留 nil”为由制造连续 breaking change。
 
 本次最终迁移表：
@@ -48,7 +48,7 @@
 
 - `CalcitTypeAnnotation::Optional(T)` 能表达 `T | nil`；
 - `CalcitTypeAnnotation::JsNullish(T)` 独立表达 JavaScript 宿主空值，不与 Optional/Option 相互匹配；
-- `nil` 推断为 `Unit`，且 `Unit` 可以匹配 `Optional<T>`；
+- `nil` 与 `Unit` 过去共享静态表示，导致声明为 `Unit` 的副作用函数仍可能实际返回 nil；
 - `nil?` / `some?` 已支持分支内的 Optional 类型收窄；
 - core 已定义 `Option<T>`、`Result<T, E>` 及基本组合函数；
 - `get` 对 List、Map 和 String 已采用可能缺失的返回推断。
@@ -64,7 +64,7 @@
 
 ### Unit
 
-`Unit` 只用于副作用操作或明确没有有意义返回值的表达式，例如写文件、注册 watcher。新代码显式返回 `&unit`；它与 `nil` 不相等、不会通过 `nil?`，JavaScript 后端生成 `void 0`（而 `nil` 仍生成 `null`）。为了兼容既有代码，标注为 `Unit` 的位置仍可接受旧的 `nil`，而 `;nil` 也保留为旧的兼容宏；新业务代码不得把两者当 Unit 标记或缺失值容器。
+`Unit` 只用于副作用操作或明确没有有意义返回值的表达式，例如写文件、注册 watcher。新代码显式返回 `&unit`；它与 `nil` 不相等、不会通过 `nil?`，JavaScript 后端生成 `void 0`（而 `nil` 仍生成 `null`）。`Unit` 标注不再接受 nil；`nil` 具有独立的 `Nil` 静态类型，并且只有 Nil 可以进入遗留 `Optional<T>`。`;nil` 保留为返回 Nil 的兼容宏，不能用作 Unit 标记；副作用函数应以 `&unit` 或最终得到 Unit 的 `do` 收尾。
 
 ### Optional<T>（遗留内部表示）
 
@@ -97,7 +97,7 @@ JS FFI 是无法立即消除的宿主空值边界。原生属性读取、方法
 - 将底层 `&parse-float` 和 `&get-env` proc 的 nullable 返回标成 Optional，作为公开名义 API 之下的兼容边界；
 - 将 `rest` / `butlast` 对空 List 的结果统一为同类型空 List，并同步 Native、JS、WASM；`rest` 与 `empty` 的公开契约改为 `T -> T`，因此确定存在的集合/String 不再被无条件提升为 Optional，而显式 Optional/nil 输入仍保留其可空类型；
 - 公开 core 的 `first`、`last`、`nth`、`get`、`get-in` schema 返回名义 `Option`；内部 `&list:first`、`&list:nth`、`&map:get` 等 raw primitive 保留 nullable 表示并标记为 internal；
-- `analyze weak-types` 将裸 `nil` 与 `;nil` 都纳入审计，仅在结构上可证明的返回位置读取函数契约，并区分 `declared-unit`、`declared-optional` 与 `unresolved`；JSON 对后两类迁移债务发出 `W_NIL_TYPE_DEBT`；
+- `analyze weak-types` 将裸 `nil` 与 `;nil` 都纳入审计，仅在结构上可证明的返回位置读取函数契约，并区分 `declared-unit`、`declared-optional` 与 `unresolved`；三类都属于迁移债务并由 JSON 发出 `W_NIL_TYPE_DEBT`；
 - `analyze.weak-types` 的机器协议升级到 schema v2，避免旧消费者在 v1 下错误接受新增的封闭 intent/diagnostic 枚举；
 - 修正既有 `optionally` 桥接函数的契约为 `Optional<T> -> Option<T>`，为遗留 nullable 边界提供不丢失类型关系的显式出口；
 - 为上述规则增加单元测试。
@@ -106,7 +106,7 @@ Phase 1 的类型契约修正本身不改变相关过程的运行时返回值；
 
 低层专用推断不能通过批量 `unsafe-coerce` 清理：core 宏在检查列表形状后读取 AST，当前类型系统尚不能携带“非空列表”及 guard clause 终止证据。此类宏改用明确的 `&` raw primitive；公开包装器始终保留 Option 外层，不把内部 nullable 表示扩散成 API。
 
-nil 审计也坚持证据边界：返回的 `do` 只有最后一项继承返回契约，返回的 `if` 只有结果分支继承契约；中间步骤、集合内容和尚未建模的控制流仍标成 `unresolved`。`declared-unit` 不计入迁移债务，`declared-optional` 则继续提示迁移到 Option/Result。
+nil 审计也坚持证据边界：返回的 `do` 只有最后一项继承返回契约，返回的 `if` 只有结果分支继承契约；中间步骤、集合内容和尚未建模的控制流仍标成 `unresolved`。`declared-unit` 提示改为真正的 `&unit`，`declared-optional` 则继续提示迁移到 Option/Result。
 
 ### Phase 2：建立名义安全 API
 
@@ -141,6 +141,17 @@ core 自举宏已经迁到明确的 `&` raw primitive，公开 `first`、`last`
 - Optional 仅由迁移工具与 internal raw primitive 识别；公开 schema 由稳定诊断阻断；
 - 审计 JS/WASM 后端，确保名义类型的表示和分支行为一致。
 
+### Phase 5：Nil / Unit 运行时与 ABI 分离
+
+- 为 `nil` 增加独立的 `Nil` 类型标注，禁止其匹配 `Unit`，同时保留 Nil 到遗留 `Optional<T>` 的关系；
+- Native effect proc 返回真实 Unit；有意义的 mutation（例如 `reset!`）保留并声明其写入值，而不是伪造 Unit；
+- JavaScript 后端用 `null` 表示 Nil、用 `undefined` 表示 Unit，并在相等、哈希、格式化、类型反射和 typed decode 中保持二者可区分；
+- data-shape ABI 增加独立 Nil 节点并升级版本，防止旧 runtime 静默把 Nil 当 Unit；Cirru EDN 和 JSON 均拒绝序列化 Unit；
+- `;nil` 的零参数 hint form 必须生成真正的 Nil 返回；`assert-type` / `assert-traits` 在 JS 中保留被断言的值；
+- 对 js-ffi、Respo 与 Recollect 做组合验证，只迁移明确的 effect tail；DOM 缺失、宿主 nullish 和框架动态边界不机械替换。
+
+实施跟踪见 [#428](https://github.com/calcit-lang/calcit/issues/428) 与 [#429](https://github.com/calcit-lang/calcit/issues/429)。
+
 ## 类型提示修复策略
 
 迁移应优先给出局部、可机械执行的建议：

package/editing-history/20260823-0401-guard-range-progress.md

@@ -0,0 +1,9 @@
+# Guard eager range construction
+
+- Capped eager range cardinality at the JavaScript array length limit in both
+  Native and JavaScript backends, returning the same controlled error before
+  iteration.
+- Detect floating-point steps that no longer change the current value, avoiding
+  infinite loops at large magnitudes.
+- Added Native regression coverage for oversized and non-advancing ranges; the
+  shared Calcit regression runs through Native and JavaScript integration suites.

package/editing-history/20260824-0318-range-backend-consistency.md

@@ -0,0 +1,13 @@
+# range backend consistency and allocation
+
+- Native and JavaScript `range` now reject non-finite inputs and use exact
+  equality for the empty half-open interval, avoiding divergent edge behavior.
+- JavaScript range generation handles negative steps and fills one backing
+  array directly instead of creating a new `CalcitSliceList` wrapper for every
+  item. A local 20 × 200,000-item benchmark improved from 40.96 ms to 20.71 ms.
+- Native range generation reserves the estimated vector capacity with
+  `try_reserve_exact`, retaining the existing iterative floating-point behavior
+  while avoiding repeated vector growth and reporting impossible allocations.
+- Regression coverage runs descending and fractional ranges in the native and
+  JavaScript project suites; definition-attached tests also cover descending
+  ranges in `calcit.core`.

package/editing-history/20260824-0645-unit-truthiness-review.md

@@ -0,0 +1,6 @@
+# Align Unit truthiness across runtimes
+
+- Treat `&unit` as false in native conditionals and `not`, matching JavaScript (`void 0`) and WebAssembly (`0`).
+- Make `or` use the shared conditional semantics, then add a Unit regression test.
+- Replace internal no-return `;nil` tails with `&unit`, while retaining `;nil` for legacy absence semantics.
+- Cover `json-stringify &unit` as a type error.

package/editing-history/20260824-0655-project-module-merge-review.md

@@ -0,0 +1,4 @@
+# Complete project-module merge review coverage
+
+- Avoid cloning a dependency snapshot when it has no namespaces owned by the project package.
+- Extend the transitive self-dependency regression to cover project subnamespaces and preserve strict conflicts for unrelated namespaces.

package/editing-history/20260824-0705-unit-effect-return-review.md

@@ -0,0 +1,5 @@
+# Complete Unit effect-return review
+
+- Document that `not` accepts Unit as a falsey input in its builtin help and core documentation.
+- Ensure `each` and `&doseq` discard callback or body values and return Unit for non-empty traversals.
+- Add definition-attached Unit regressions for both traversal helpers.

package/editing-history/20260824-1540-scaffold-data-kind-schema.md

@@ -0,0 +1,6 @@
+# Reconcile concrete data-definition schemas in scaffold plans
+
+- Accept an existing concrete `StructDef` or `EnumDef` schema when a scaffold plan declares the corresponding broad definition-kind marker.
+- Decode zero-payload canonical schema wrappers consistently at both snapshot-load and write-validation boundaries, avoiding their accidental interpretation as anonymous enum values.
+- Keep the compatibility rule directional and limited to data-definition schemas so unrelated function and value schemas remain strict.
+- Cover both struct and enum definition markers with a regression test.

package/editing-history/20260824-2119-validate-number-call-metadata.md

@@ -0,0 +1,8 @@
+# Validate specialized number-call metadata
+
+- Guard the native NumberBinary fast path with the stored proc identity, so a
+  manually constructed executable call with stale or mismatched metadata uses
+  ordinary dispatch rather than a different arithmetic operation.
+- Classify the small supported native-proc set before resolving argument types,
+  keeping all other calls off the specialization analysis path.
+- Rename the function-hint regression to describe its compile-time-only role.

package/editing-history/20260824-2155-stable-js-struct-layout.md

@@ -0,0 +1,11 @@
+# Stable JavaScript Struct layout
+
+- Align JavaScript Struct, Enum, and implementation metadata ordering with native lexical tag-name ordering.
+- Make typed JS Struct reads and updates consume their precomputed field indices while retaining field-tag consistency checks.
+- Canonicalize Cirru EDN Struct field/value pairs during parsing so serialized data adopts the same layout.
+- Cover reversed tag-registration order and invalid indexed access in the JavaScript runtime regression suite.
+- Add `yarn bench-struct-index` to compare the previous tag-lookup codegen path with indexed access plus its schema-drift check.
+- Normalize paired metadata in exported JS Struct, StructDef, and Impl constructors for compatibility with older runtime values.
+- Align native `&struct:nth` index/tag validation and empty JS `with-at` arity errors with the indexed update primitives.
+
+Focused JS benchmark on Apple arm64 / Node 24.4.1, 5,000,000 reads over a 32-field Struct (three runs): tag lookup median 574.51 ms; indexed access with field-tag validation median 37.56 ms (~15.3x faster). Native indexed Struct access is unchanged by this JS-only runtime/codegen optimization.

package/editing-history/20260824-2224-struct-index-review-followups.md

@@ -0,0 +1,7 @@
+# Struct index review follow-ups
+
+- Reused native struct index validation for reads, including exact numeric indices and optional field-tag checks.
+- Canonicalized paired struct metadata at exported JavaScript constructor boundaries so legacy or external callers cannot create unsorted field/value layouts.
+- Aligned JavaScript `withAt` arity validation with the native runtime.
+- Added reverse-registration EDN, legacy metadata, stale-tag, fractional-index, and empty-update regressions.
+- Re-ran the full Rust, Calcit, JavaScript, IR, WASM, and agent-interface validation suites.

package/editing-history/20260824-2233-indexed-struct-js-regressions.md

@@ -0,0 +1,5 @@
+# Indexed Struct JavaScript regressions
+
+- Covered fractional indices in JavaScript indexed Struct reads.
+- Covered stale field tags in JavaScript indexed `assocAt` and `withAt` updates.
+- Kept the regression matrix aligned with native indexed Struct validation.

package/editing-history/20260824-2256-dynamic-method-analysis.md

@@ -0,0 +1,9 @@
+# Dynamic method analysis
+
+- Added `analyze dynamic-methods` to inventory unresolved method dispatch without mixing in unrelated preprocessing warnings.
+- Added stable codes for prefix and postfix dynamic dispatch findings.
+- Added project-only default scope, opt-in dependency scope, deterministic de-duplication, JSON and summary output.
+- Added `--max` as an incremental CI performance policy for existing typed projects.
+- Verified the initial project-only inventory against current Respo and Recollect main branches.
+- Respo reports 8 project findings and passes a reviewed `--max 8`; Recollect reports 0 project findings and 4 reachable dependency findings.
+- Respo native tests pass 25/25 and Recollect native tests pass 9/9 with the installed branch build.

package/editing-history/20260824-2329-dynamic-method-review-followups.md

@@ -0,0 +1,7 @@
+# Dynamic method analysis review follow-ups
+
+- Documented the accepted `text` output alias and advertised `dynamic-methods` in parent CLI help.
+- Preserved every imprecisely located generated warning while still de-duplicating warnings with exact Snapshot coordinates.
+- Added a module-backed CLI fixture proving project-only and reachable dependency scopes end to end.
+- Strengthened the policy smoke test to require individual finding rows.
+- Updated the upgrade CI template, checklist, and troubleshooting matrix to use the focused dynamic-method policy.

package/editing-history/202608241525-release-01343.md

@@ -0,0 +1,5 @@
+# Release 0.13.43
+
+- Align Unit truthiness across native, JavaScript, and WASM runtimes.
+- Reconcile existing `StructDef` and `EnumDef` definitions with matching scaffold architecture markers.
+- Include the range backend consistency and performance improvements merged after 0.13.42.

package/editing-history/202608241731-contiguous-executable-calls.md

@@ -0,0 +1,34 @@
+# Contiguous executable calls
+
+## Summary
+
+- Keep immutable ordinary proc, function, and method call nodes in
+  `CalcitList::Vector` after preprocessing instead of rebuilding them as
+  persistent `TernaryTreeList` values.
+- Preserve persistent storage for syntax calls because their runtime handlers
+  still rely on cheap structural `skip` operations.
+- Leave quoted and runtime List values untouched; the optimization is confined
+  to the result of preprocessing executable non-syntax calls.
+- Cover nested ordinary calls and the syntax/quote boundary with representation
+  regression tests.
+
+## Performance notes
+
+- A broader prototype that also converted syntax calls regressed a 200,000
+  iteration tail loop by about 6%, since `CalcitList::skip` rebuilt a persistent
+  tail from the Vector on every `if` evaluation. A borrowed syntax-argument view
+  is required before that representation can change safely.
+- On five release runs of the same 1,000,000-iteration loop, the retained
+  ordinary-call-only change reduced median internal runtime from 7,810.963 ms
+  to 6,998.677 ms (~10.4%) and median user CPU from 7.23 s to 6.95 s (~3.9%).
+
+## Validation
+
+- `cargo fmt --all -- --check`
+- `cargo test -q`
+- `cargo clippy --all-targets -- -D warnings`
+- `yarn compile`
+- `yarn check-agent-interface`
+- `yarn check-all`
+- Current `calcit-lang/recollect` and `Respo/respo.calcit` main heads, including
+  native/JS tests, Respo production build, and real-browser interaction.

package/editing-history/202608241920-borrowed-syntax-arguments.md

@@ -0,0 +1,34 @@
+# Borrowed syntax arguments
+
+## Context
+
+After ordinary executable calls moved to contiguous `CalcitList::Vector` storage, syntax dispatch still built a persistent tail with `skip(1)` on every evaluation. Converting syntax roots to vectors before changing that API regressed hot loops because each syntax call reconstructed a list.
+
+## Changes
+
+- Added `CalcitListView`, a borrowed read-only range over either vector or persistent list storage.
+- Routed `call_expr`, argument evaluation, syntax dispatch, and ref syntax handlers through borrowed views.
+- Kept allocation explicit with `to_vec` only where owned stack/error data or function bodies require it.
+- Normalized all preprocessed executable call roots, including syntax calls, to contiguous storage while preserving quoted list values.
+- Added view coverage for both storage backends, nested skips, iteration, indexing, and invalid bounds; updated preprocessing representation coverage.
+
+## Performance
+
+The release benchmark runs a two-argument tail-recursive loop for 1,000,000 iterations and returns `500000500000`.
+
+- `main` (`1ef20077`) internal median: 7,062.173 ms; user CPU median: 7.06 s.
+- This change internal median: 5,920.961 ms; user CPU median: 6.00 s.
+- Improvement: 16.2% internal runtime and 15.0% user CPU.
+
+## Validation
+
+- `cargo fmt --all -- --check`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test -q`
+- `yarn compile`
+- `yarn check-agent-interface`
+- `yarn check-all`
+- Latest Recollect `a694d4c`: native tests 9/9, test-entry JS generation and Node runtime passed. Its default entry retains the same four pre-existing dependency type warnings.
+- Latest Respo `ead78c3`: tests 25/25, JS generation and Vite production build passed. Browser Todo interaction added one task and produced zero console errors.
+
+The downstream Dynamic coverage remains unchanged at 204/405 (50.4%) for Recollect and 284/1034 (27.5%) for Respo.

package/editing-history/202608241924-unify-editing-history-directory.md

@@ -0,0 +1,7 @@
+# Unify editing history storage
+
+- Moved the remaining timestamped history notes from the repository root and legacy `history/` directory into `editing-history/`.
+- Renamed `Agents.md` to the conventional `AGENTS.md` filename.
+- Documented `editing-history/` as the single required destination for future per-commit notes.
+
+Keeping one directory prevents validation tools and contributors from repeatedly migrating the same files and makes the historical index predictable.

package/editing-history/202608242013-typed-native-number-ops.md

@@ -0,0 +1,34 @@
+# Typed native number operations
+
+## Context
+
+Typed functions carried an injected one-argument `hint-fn` form in their native runtime body. Tail recursion therefore re-evaluated compile-time metadata on every iteration. Native calls also discarded proven `Number` argument types before evaluation and rebuilt a temporary argument vector for the normal proc dispatcher.
+
+## Changes
+
+- Capture surrounding-function `hint-fn` metadata in `CalcitFn`, then remove that one-argument form from the executable body. Targeted two-argument hints retain their runtime behavior.
+- Add internal executable-call metadata that does not affect Calcit List equality, ordering, hashing, display, or language-level mutation behavior.
+- Mark exact two-argument `&+`, `&-`, `&*`, `&/`, `&<`, and `&>` calls only when both processed arguments resolve to `Number`.
+- Evaluate specialized arguments exactly once from left to right into a fixed two-value array, execute the numeric operation directly, and preserve the existing dynamic proc error path if static evidence becomes stale.
+- Leave Dynamic, unresolved, wrong-arity, spread, JS, and WASM calls on their existing paths.
+
+## Performance
+
+The release benchmark runs the same two-argument tail-recursive loop for 1,000,000 iterations.
+
+- Typed pre-change internal median: 1,664.953 ms.
+- Typed post-change internal median: 457.819 ms, a 72.5% reduction after removing runtime metadata evaluation and adding the specialized calls.
+- On the post-change binary, the specialized typed loop median was 457.819 ms versus 483.450 ms for the otherwise identical Dynamic loop, a 5.3% typed fast-path improvement.
+
+## Validation
+
+- `cargo fmt --all -- --check`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test -q` (463 + 241 + 24 + 4 tests)
+- `yarn compile`
+- `yarn check-agent-interface` (13/13)
+- `yarn check-all`, including native, JS, IR, and WASM checks
+- Latest Recollect `a694d4c`: native tests 9/9; test-entry JS generation and Node runtime passed. Its default entry retains the same four pre-existing dependency type warnings.
+- Latest Respo `ead78c3`: tests 25/25, JS generation, Vite production build, and a browser Todo interaction passed with zero console errors.
+
+The downstream Dynamic boundaries remain observable rather than being forced static: Recollect reports 204/405 (50.4%) Dynamic type positions, and Respo reports 284/1034 (27.5%).

package/editing-history/20260825-0020-indexed-enum-match.md

@@ -0,0 +1,34 @@
+# Indexed enum match dispatch
+
+## Context
+
+Issue #422 continues the performance roadmap after scoped dynamic-method diagnostics. Native `match` retained typed enum structure but still scanned branch tags, while JS emitted an if/else chain.
+
+## Changes
+
+- Exposed the existing enum tag-to-variant declaration index.
+- Rewrote statically known, semantics-safe `match` forms into an internal declaration-ordered branch table.
+- Declined the rewrite for duplicate tags, unknown tags, or a wildcard before the final branch so source-order behavior stays unchanged.
+- Selected native branches directly through the enum variant index.
+- Emitted JS integer-tag `switch` dispatch for indexed matches.
+- Kept WASM compatible with the internal table representation.
+- Added focused table/codegen tests and native/JS comparison benchmarks.
+- Updated the optimization catalog and native-match RFC.
+
+## Compatibility notes
+
+- No user-facing syntax was added.
+- `CalcitEnumValue` layout and all enum construction/serialization boundaries remain unchanged.
+- Dynamic and anonymous enum matches retain the original linear representation.
+- Runtime type, payload arity, wildcard, and no-match behavior remain explicit.
+
+## Validation plan
+
+- `cargo fmt`
+- `cargo clippy --all-targets -- -D warnings`
+- `yarn compile`
+- `cargo test`
+- `yarn check-all`
+- `yarn check-agent-interface`
+- `yarn bench-enum-match`
+- current Respo and Recollect main regression

package/editing-history/20260825-0100-indexed-enum-match-validation.md

@@ -0,0 +1,7 @@
+# Indexed enum match validation fixes
+
+- Fixed the release benchmark example to import internal Calcit value types from the public `calcit::calcit` module.
+- Reduced the indexed JS match helper argument count and derived the wildcard slot from the internal table layout, keeping Clippy clean without changing generated semantics.
+- Applied `cargo fmt` to the touched Rust code.
+- Verified `cargo clippy -- -D warnings`, `cargo test`, `yarn compile`, `yarn check-all`, and `yarn check-agent-interface`.
+- Measured the 16-variant last-branch benchmark at 291.55 ms for linear native tag scanning versus 108.35 ms for indexed lookup; the JS comparison measured 37.62 ms versus 31.06 ms.

package/editing-history/20260825-0120-indexed-enum-match-review.md

@@ -0,0 +1,7 @@
+# Indexed enum match review fixes
+
+- Kept indexed JS match control flow inside an IIFE with real branch returns, so non-tail and assignment contexts cannot leak into wildcard or no-match handling after a successful case.
+- Included the matched value expression in `js-await` detection while continuing to exclude nested function scopes.
+- Added native runtime coverage for indexed branch selection and arity-mismatch wildcard fallback.
+- Added JS codegen coverage for non-return labels and awaited matched values.
+- Re-ran formatting, Clippy, Rust tests, TypeScript compilation, Agent interface checks, and the native/JS/WASM integration suite.

package/editing-history/20260825-1215-typed-literal-paths.md

@@ -0,0 +1,56 @@
+# Typed literal collection paths
+
+## Context
+
+Issue #424 completes the last executable optimization in roadmap #409. Public
+`get-in` and `assoc-in` are recursive Calcit functions, so literal paths still
+paid for path-list traversal and dynamic dispatch even when type inference had
+already proved every hop.
+
+The public APIs deliberately reject Struct traversal. Static evidence must not
+turn either API into an alternate Struct field accessor; required fields remain
+`(:field value)` and direct `assoc` operations.
+
+## Changes
+
+- Expand a non-empty literal `get-in` path only when the base and every
+  collection value that needs another traversal step are statically
+  non-Dynamic and no hop is a Struct. The final payload may remain Dynamic.
+- Preserve single evaluation, nil short-circuiting, `%some` / `%none`, missing
+  keys, and an explicit Struct guard at every generated lookup hop.
+- Expand `assoc-in` only for Map-only paths with a statically non-Dynamic final
+  payload in this first phase. Generated code uses direct map
+  contains/get/assoc primitives while retaining missing-map construction, nil
+  normalization, evaluation order, and Struct rejection.
+- Keep empty paths, Dynamic or unknown hops, Struct boundaries, and mixed
+  `assoc-in` containers on the original recursive functions.
+- Add a checked-in native/generated-JS comparison benchmark and update RFC P6
+  to the reconciled Struct-safe contract.
+
+## Measurements
+
+The 100,000-operation release benchmark produced the same outputs for typed and
+dynamic variants. The checked-in warm/sample driver measured native at 2.98 s
+versus 5.48 s for read (~1.8x faster), and 1.68 s versus 5.02 s for write
+(~3.0x faster). Generated JS medians were 33.9 ms versus 50.9 ms for read (~33%
+faster), and 16.2 ms versus 696.0 ms for write (~43x faster). Run `yarn
+bench-literal-paths` to reproduce the focused comparison.
+
+## Validation
+
+- `cargo fmt --all`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test`
+- `yarn check-all`
+- `yarn bench-literal-paths`
+- current `calcit-lang/recollect` main: native tests 9/9 and generated test-entry
+  JS runtime passed
+- current `Respo/respo.calcit` main: native tests 25/25, JS generation passed,
+  and the browser demo rendered without runtime errors when Vite was pointed at
+  this workspace's matching 0.13.43 JS runtime
+
+The published downstream JS runtimes lagged the compiler during validation
+(Recollect 0.13.19, Respo 0.13.40). Respo's default package therefore lacks the
+new struct `nthAt` method until the matching runtime release is installed; no
+downstream files were changed. Recollect's default demo build also retains four
+pre-existing Respo dependency type warnings, while its own test entry passes.

package/editing-history/20260825-1344-typed-literal-path-review.md

@@ -0,0 +1,17 @@
+# Typed literal path review follow-up
+
+- Suppressed diagnostics only while reprocessing compiler-generated path
+  guards; original caller expressions are checked before specialization.
+- Added return-type inference for preprocessed `match` forms so expanded
+  `get-in` retains its `Option<T>` result type.
+- Allowed a Dynamic final `get-in` payload while retaining the stricter static
+  final-payload requirement for Map-only `assoc-in`.
+- Expanded the runtime fixture to cover nil intermediates, stored Options,
+  indexed lookup, runtime Struct rejection, fallback behavior, and actual
+  path/replacement side-effect order on native and generated JS.
+- Made `yarn bench-literal-paths` build the JS runtime, execute correctness
+  assertions, verify typed/dynamic structural equality, and report warm native
+  and generated-JS median samples.
+
+Validation: `cargo fmt --all -- --check`, `cargo clippy --all-targets -- -D
+warnings`, `cargo test`, `yarn check-all`, and `yarn bench-literal-paths`.

package/editing-history/20260825-1505-typed-method-native-op.md

@@ -0,0 +1,23 @@
+# Typed method native executable-op follow-up
+
+- Updated performance roadmap issue #409 after #424/#425 merged and opened
+  #426 for the remaining static-method/native-op metadata gap.
+- Confirmed that typed method binding already existed; the missing link was
+  rebuilding its resolved callable as an executable call with current
+  `CalcitCallKind` classification.
+- Added native typed remainder execution while retaining proc-identity checks,
+  left-to-right single argument evaluation, and ordinary dynamic error
+  fallback for stale static evidence. The fast path reuses the normal
+  remainder implementation so its integer conversion and error behavior stay
+  identical.
+- Added native/generated-JS correctness fixtures and warm/sample benchmarks for
+  typed method, intentionally Dynamic method, and direct proc forms.
+- Against `main@159b4520`, the 500,000-iteration native medians changed from
+  547.33 ms to 485.50 ms for typed `.rem` (~11.3% faster) and from 548.42 ms to
+  500.36 ms for direct `&number:rem` (~8.8% faster). Dynamic dispatch remained
+  intentionally unspecialized. Generated JS typed/direct forms remained
+  equivalent and substantially faster than Dynamic dispatch.
+
+Validation includes Rust formatting, clippy/tests, `yarn check-all`, the focused
+benchmark, current upstream Recollect native/generated-JS runtime checks, and
+Respo native tests plus generated-JS/Vite production build.

package/editing-history/20260825-1540-nil-unit-runtime-separation.md

@@ -0,0 +1,15 @@
+# Nil and Unit runtime separation
+
+- Split the static `Nil` and `Unit` annotations: `nil` remains absence and
+  `&unit` is the only canonical no-result value.
+- Aligned native effects, generated JavaScript, runtime identity, hashing,
+  formatting, typed data-shape decoding, and serialization boundaries with
+  that distinction; bumped the data-shape ABI to reject stale runtimes.
+- Preserved `;nil` as a real Nil expression, normalized only missing safe JS
+  property/call results to Nil, and kept raw `aget` capable of observing Unit.
+- Migrated explicit effect tails in js-ffi and Respo, then exercised Recollect
+  against all three local worktrees to protect dynamic framework behavior.
+
+Validation: `cargo test`, `npm run compile`, `npm run check-js-runtime`, native
+and generated-JS core suites, js-ffi Node/browser contracts, Respo tests/build,
+and Recollect unit/JS/build checks.

package/editing-history/20260825-1725-typed-method-error-stack-review.md

@@ -0,0 +1,10 @@
+# Typed method error-stack review
+
+- Kept the typed number-binary fast path aligned with normal proc dispatch by
+  attaching the active call stack when a specialized operation returns an
+  otherwise stackless error.
+- Added a regression test comparing invalid specialized and ordinary remainder
+  dispatch with stack tracking enabled.
+
+Validation: `cargo fmt --all -- --check`, targeted runner tests, `cargo clippy
+--all-targets -- -D warnings`, and `cargo test`.

package/editing-history/20260825-1733-nil-unit-doc-review.md

@@ -0,0 +1,5 @@
+# Nil / Unit documentation review
+
+- Corrected the static-analysis type table after the runtime/type split.
+- `Unit` is represented by `&unit` and no longer accepts `nil`.
+- `Nil` is documented as a distinct legacy absence type.

package/editing-history/20260825-1758-nil-unit-review-followup.md

@@ -0,0 +1,6 @@
+# Nil / Unit review follow-up
+
+- Kept zero-argument `(:: 'Nil)` forms as the builtin Nil annotation in both parser representations.
+- Made the JavaScript console formatter render nested Unit values as `&unit` while preserving nested nil handling.
+- Added parser, formatter, and typed-EDN Nil decoder regressions for the reviewed edge cases.
+- Documented why transaction tests use package metadata: serialized format versions are normalized, so version mutations cannot exercise change detection.

package/editing-history/20260825-1845-release-01344.md

@@ -0,0 +1,6 @@
+# Release 0.13.44
+
+- Separate canonical Unit from Nil across native, JavaScript, and WASM runtimes.
+- Canonicalize effect primitive Unit contracts while preserving `reset!`'s written value.
+- Add static migration diagnostics for legacy nil-as-Unit code and explicit host nullish boundaries.
+- Include the typed literal collection and typed method native-operation performance improvements merged after 0.13.43.