@calcit/procs 0.12.56 → 0.12.57

package/editing-history/2026-04-13-1600-tuple-to-enum-rewrite.md

@@ -1,13 +0,0 @@
-## 概要
-
-为 tuple-to-enum 自动改写实现预处理阶段支持。当函数参数 schema 标注为 enum 类型时,
-调用者传递的 untyped tuple `:: :tag payload` 自动改写为 `%:: Enum :tag payload`。
-
-## 知识点
-
-- `CalcitTypeAnnotation::resolve_to_enum_with_ref()` 对应 struct 端已有的 `resolve_to_struct_with_ref()`
-- `resolve_enum_from_program()` 通过 `lookup_runtime_ready_registered` + `lookup_def_code_registered` 两级缓存查找
-- tuple 改写只替换 head proc (`NativeTuple` → `NativeEnumTupleNew`) 并插入 enum 引用，不对 tag/payload 做验证（由 `check_enum_tuple_construction` 兜底）
-- JS codegen 需要 `Calcit::Import` 而非 `Calcit::Enum` 内联值，通过 TypeRef 路径判断走 SameFile 还是 NsReferDef
-- map-to-record 改写验证 key 合法性，tuple-to-enum 改写不验证（差异源于 struct field 是封闭集合，enum tag 验证已有独立检查）
-- Cirru tag-match 零载荷变体的 pattern 是 `(:ok)` 而非 `:ok`（后者在 pair 中被当作 body）

package/editing-history/2026-04-13-2309-typeslot-enum-compile-safety.md

@@ -1,45 +0,0 @@
-# TypeSlot + Enum 编译期安全增强
-
-## 概要
-
-让 `deftype-slot` / `bind-type` 机制真正实现编译期 enum variant 校验。此前 TypeSlot 绑定的 enum 在自动推导 (`:: → %::`) 路径上缺乏变体验证，导致拼写错误或不存在的 variant 无法在 `cr js` / `--check-only` 时报出。
-
-## 修改的文件
-
-### `src/calcit/type_annotation.rs`
-
-- `resolve_to_enum_with_ref()`: 新增 `TypeSlot` 分支，通过 `resolve_type_slot()` 解析绑定类型后委托
-- `matches_with_bindings()`: 双向 `Tuple/Enum` 匹配 — 原先只有 `(Tuple, Enum)` 方向，TypeSlot 解析后顺序会翻转，新增 `(Enum, Tuple)` 方向
-
-### `src/calcit.rs`
-
-- 将 `resolve_type_slot` 加入 `pub use` 导出列表
-
-### `src/runner/preprocess.rs`
-
-- `resolve_enum_value()`: 在 `as_struct()` 调用前增加 TypeSlot 解析（避免 `&CalcitStruct` 生命周期问题）
-- 新增 `try_rewrite_local_fn_tuple_args_to_enum_tuples()`: 对本地函数调用（如回调 `d!`）也执行 tuple→enum 自动重写
-- 主预处理 `Calcit::Local` 分支: 增加 local fn 调用的重写+类型检查（clone 避免借用冲突）
-- `try_rewrite_single_tuple_to_enum_tuple()`: 增加变体验证 — 重写后立即检查 tag 是否是 enum 的合法 variant，不合法则发出警告
-
-### `src/bin/cr_tests/type_fail.rs`
-
-- 新增 `type_fail_type_slot_enum_invalid_variant` 测试，验证 TypeSlot 绑定的 enum 在自动重写路径下能正确检测不存在的 variant
-
-### `calcit/type-fail/type-slot-enum-invalid-variant.cirru`
-
-- 新增测试 fixture：声明 `defenum Action`、通过 TypeSlot 绑定、调用 `takes-action $ :: :nonexistent |hello`，期望产生 variant 不存在警告
-
-## 知识点
-
-1. **TypeSlot 解析链**: `TypeSlot(name) → resolve_type_slot(name) → CalcitTypeAnnotation (通常是 TypeRef)` → 再通过 `resolve_to_enum_with_ref()` 得到 enum 定义。这是一个两步间接过程。
-
-2. **`matches_with_bindings` 双向性**: TypeSlot 被解析后会调 `bound.matches_with_bindings(other, bindings)`，此时 self/other 顺序可能翻转。所有组合型匹配（如 Tuple/Enum）都需要双向 pattern。
-
-3. **`as_struct()` 返回引用**: `CalcitTypeAnnotation::as_struct()` 返回 `Option<&CalcitStruct>`，无法从临时解析结果中返回引用。修复方案是在调用点先解析 TypeSlot 再调 `as_struct()`。
-
-4. **自动重写的 `%::` 不经过 `preprocess_expr`**: `try_rewrite_single_tuple_to_enum_tuple` 构造的 `[NativeEnumTupleNew, ...]` 列表是在预处理完参数后生成的，不会经过 `check_proc_arg_types` 中的 `check_enum_tuple_construction`。因此变体验证必须在重写函数内部完成。
-
-5. **Local fn 调用缺少自动重写**: 原先只有 `CalcitFn` 调用走 `try_rewrite_tuple_args_to_enum_tuples`。`Calcit::Local` 调用（如回调参数 `d!`）需要单独处理。新函数接受 `CalcitFnTypeAnnotation` 而非 `CalcitFn`。
-
-6. **Lambda-in-map 的 EXPECTED_FN_TYPE 盲区**: `fn (e d!)` 在 hashmap 值（如 `:on-click`）中时，`d!` 不会获得 `EXPECTED_FN_TYPE` 注入的类型信息。目前通过显式 `%:: Op :variant` 写法绕过，属于已知架构限制。

package/editing-history/2026-04-14-1500-loose-record-syntax.md

@@ -1,32 +0,0 @@
-# 2026-04-14 15:00 — `?{}` 松散 Record 语法
-
-## 概要
-
-新增 `?{}` 松散 record 语法，允许不声明 struct 就创建 record，与 `::` 无类型 tuple 对称。
-在函数参数有 struct 类型标注时，预处理阶段自动改写为 `%{} StructDef ...`。
-
-## 改动文件
-
-| 文件 | 变更 |
-|------|------|
-| `src/calcit/proc_name.rs` | 新增 `NativeLooseRecord` proc 变体，`?{}` 序列化，类型签名 |
-| `src/data/cirru.rs` | `"?{}"` token 解析为 `Calcit::Proc(NativeLooseRecord)` |
-| `src/calcit/record.rs` | `LOOSE_RECORD_NAME`、`is_loose()`、`from_loose_pairs()` |
-| `src/builtins/records.rs` | `call_loose_record()` 运行时：验证 tag 键、排序、排重 |
-| `src/builtins.rs` | 分发 `NativeLooseRecord => call_loose_record(args)` |
-| `src/calcit.rs` | Display: 松散 record 显示为 `(?{} ...)` |
-| `src/runner/preprocess.rs` | `try_rewrite_loose_record_args_to_struct_records`、类型推断、skip core arg check |
-| `ts-src/js-record.mts` | JS 运行时 `_$q__$M_` 函数 |
-| `calcit/test-record.cirru` | `test-loose-record-rewrite` 集成测试 |
-| `docs/features/records.md` | 文档：松散 record 语法、自动改写、类型对称表 |
-
-## 性能优化
-
-- **预处理改写链合并重建**：三步改写（map→record、loose→struct、tuple→enum）原先每步都重建 `ys` (CalcitList)，优化为仅在有改写时统一重建一次，减少 CalcitList push 操作。
-- **JS 排序比较器修正**：将重复字段检测从 sort comparator 中移出（comparator 内 throw 违反排序契约），改为排序后线性扫描相邻元素，行为更可靠。
-
-## 知识点
-
-- `EdnTag::cmp` 按全局 tag 池分配顺序排序（整数 index），**不是**字典序。record 字段排序必须用 `ref_str().cmp()` 保持字母序。
-- CalcitList 基于 persistent ternary tree，`.clone()` 是 O(1) 引用计数操作。
-- Sort comparator 不应抛异常——不同排序算法对异常行为未定义。

package/editing-history/2026-04-14-2259-bidir-type-check-refactor.md

@@ -1,63 +0,0 @@
-# 202604142259 — Bidirectional Type Checking Architecture Refactoring
-
-## 概要
-
-将 `src/runner/preprocess.rs`（6199 行单体文件）拆分为模块化目录结构，
-按双向类型检查（bidirectional type checking）的概念分离关注点。
-
-## 改动详情
-
-### 模块拆分
-
-`preprocess.rs` → `preprocess/` 目录模块：
-
-| 模块 | 行数 | 职责 |
-|---|---|---|
-| `mod.rs` | ~4744 | 预处理核心：符号解析、宏展开、作用域管理、特殊语法 |
-| `type_inference.rs` | ~693 | 类型合成（synthesis）：自下而上推导表达式类型 |
-| `type_checking.rs` | ~402 | 类型检查（checking）：自上而下验证参数类型 |
-| `type_rewriting.rs` | ~398 | 类型定向重写：根据期望类型重写 AST 字面量 |
-
-### 代码去重
-
-1. **统一参数重写循环** (`rewrite_args_by_expected_type`)：
-   - 原先 4 个 `try_rewrite_*_args_to_*` 函数各自包含相同的外层循环（~30 LOC × 4）
-   - 提取为泛型 `rewrite_args_by_expected_type<F>` 函数，4 个入口各只保留闭包调用
-
-2. **统一参数类型检查循环** (`check_arg_types_loop`)：
-   - 原先 `check_local_fn_call_arg_types` 和 `check_user_fn_arg_types` 共享相同的
-     zip → resolve_type_value → matches_with_bindings → gen_check_warning 模式
-   - 提取为泛型 `check_arg_types_loop<F>` 函数，包含 variadic 处理和 spread 跳过逻辑
-
-3. **统一引用节点构建** (`build_struct_ref_node` / `build_enum_ref_node`)：
-   - 原先 map→record 和 loose-record→struct 各自复制 Import vs Struct/Enum 分支
-   - 提取为共享的 `build_struct_ref_node` 和 `build_enum_ref_node` 函数
-
-### Proc 推导提取
-
-- `infer_type_from_expr` 中的 `Calcit::Proc` 分支（~100 行 match arms）
-  提取为独立的 `infer_proc_call_return_type` 函数，提高可读性
-
-## 双向类型检查映射
-
-参照 Dunfield & Krishnaswami 的框架：
-
-| 方向 | 模块 | 入口函数 |
-|---|---|---|
-| **Synthesis** (⇒) | `type_inference` | `infer_type_from_expr`, `resolve_type_value` |
-| **Checking** (⇐) | `type_checking` | `check_*_arg_types`, `check_function_return_type` |
-| **Rewriting** (结构适配) | `type_rewriting` | `try_rewrite_*` |
-| **Context** (线程局部) | `mod.rs` | `EXPECTED_FN_TYPE`, `EXPECTED_STRUCT_TYPE` |
-
-## 为后续 match 语法扩展铺路
-
-- `type_checking.rs` 的 `check_arg_types_loop` 模式可直接复用于 match 分支检查
-- `type_inference.rs` 中已有 `infer_if_return_type` 作为分支合并的模板
-- 未来只需在相应模块中添加新函数，无需修改 `mod.rs` 的核心调度
-
-## 验证
-
-- `cargo check --lib` ✅ 零警告
-- `cargo clippy --lib -- -D warnings` ✅ 零警告
-- `cargo fmt` ✅ 格式一致
-- 链接器问题（`ld: library 'System' not found`）是环境问题，非代码变更引起

package/editing-history/2026-04-15-0120-match-syntax-exhaustiveness.md

@@ -1,20 +0,0 @@
-# match syntax with exhaustiveness checking
-
-## Summary
-
-Added native `match` syntax for enum pattern matching with compile-time exhaustiveness detection,
-as a safer alternative to `tag-match` macro. See `drafts/match-syntax-rfc.md` for full design.
-
-## Files modified
-
-- `src/calcit/syntax_name.rs` — `CalcitSyntax::Match`
-- `src/builtins/syntax.rs` — `syntax_match()` runtime
-- `src/builtins.rs` — dispatch entry
-- `src/runner/preprocess/mod.rs` — `preprocess_match()` with exhaustiveness
-- `src/codegen/emit_js.rs` — `gen_match_code()` JS output
-- `calcit/test-enum.cirru` — test cases
-
-## Key takeaway
-
-Cirru indentation creates pair-based `(pattern body)` children — same format as `tag-match`.
-Flat alternating format doesn't survive Cirru serialization round-trips.

package/editing-history/2026-04-15-1211-record-nth-optimization.md

@@ -1,44 +0,0 @@
-# `&record:nth` — Compile-Time Record Field Index Optimization
-
-## 概述
-
-新增 `NativeRecordNth` / `&record:nth` 过程，在预处理阶段将 record 字段访问优化为 O(1) 索引访问，绕过运行时的类型分发链和二分查找。
-
-## 优化前访问路径
-
-- `(:field record)` → 重写为 `(get arg :field)` → 运行时 6 次类型判断 (`nil?` → `string?` → `map?` → `list?` → `tuple?` → `record?`) → `&record:get` → `index_of()` O(log n) 二分查找
-- `&record:get record :field` → 运行时 `index_of()` O(log n) 二分查找
-
-## 优化后访问路径
-
-当预处理阶段可以通过 `resolve_type_value` + `as_struct()` 解析出 record 的 struct 定义时：
-
-- `(:field record)` → 直接重写为 `(&record:nth record <compile-time-idx>)` → 运行时 O(1) `values[idx]`
-- `&record:get record :field` → 重写为 `(&record:nth record <compile-time-idx>)` → 运行时 O(1)
-
-## 触发条件
-
-优化仅在类型信息明确时激活：
-- record 由 `%Struct ...` 构造器在本地 `let` 中创建
-- 函数参数有显式 struct 类型的 schema 标注
-
-若类型不明，回 fallback 到原有路径，不影响运行时行为。
-
-## 修改文件
-
-1. **`src/calcit/proc_name.rs`** — 新增 `NativeRecordNth` 变体 (`&record:nth`)，签名 `(record, number) → dynamic`
-2. **`src/builtins/records.rs`** — 实现 `record_nth(xs)` 运行时函数，直接 `values[idx]` 访问
-3. **`src/builtins.rs`** — 分发表连线 `NativeRecordNth => records::record_nth`
-4. **`src/runner/preprocess/mod.rs`** — 两个重写点：
-   - Tag-call (`Calcit::Tag` as head)：解析 arg 类型后索引重写
-   - `NativeRecordGet` proc call：解析 record arg 类型后索引重写
-5. **`src/runner/preprocess/type_inference.rs`** — `infer_record_nth_type()` 根据 struct 的 `field_types[idx]` 推断返回类型
-6. **`src/runner/preprocess/type_checking.rs`** — 将 `NativeRecordNth` 加入 core arg type check 跳过列表
-7. **`src/codegen/emit_js.rs`** — JS 内联代码生成 `record.values[idx]`，无函数调用开销
-
-## 知识点
-
-- `CalcitStruct.index_of(field_str)` 在编译期使用，用字段名解析排序位置
-- `resolve_type_value()` 返回 `None` 时优化不触发，安全回退
-- JS CalcitRecord 的 `.values` 数组和 Rust 端的 `values` Vec 索引一致（均按字段名字母序排序）
-- 对于真实项目（如 respo），函数参数通常缺少 struct 类型标注，优化暂不触发；后续若 schema 推断增强，无需改动 rewrite 逻辑即可自动生效

package/editing-history/2026-04-16-1936-predicate-narrowing-expansion.md

@@ -1,31 +0,0 @@
-# 扩展 extract_predicate_binding 支持更多类型谓词
-
-## 改动概要
-
-将 `extract_predicate_binding` 重构为 `extract_predicate_bindings`，支持双向窄化（true/false 分支），并新增 6 个类型谓词的窄化支持。
-
-## 修改文件
-
-### src/runner/preprocess/mod.rs
-
-- 重构 `extract_predicate_binding` → `extract_predicate_bindings`，返回 `PredicateNarrowing` 结构体（包含 `true_binding` 和 `false_binding`）
-- `preprocess_if` 中 false 分支也应用窄化信息
-- 新增谓词：`tag?` → `:tag`、`bool?` → `:bool`、`symbol?` → `:symbol`、`fn?` → `:fn`
-- 新增 `nil?`/`some?`：当变量已知为 `Optional(T)` 时，nil? 的 false 分支窄化为 `T`，some? 的 true 分支窄化为 `T`
-
-### src/calcit/proc_name.rs
-
-- `TurnTag` 的参数签名从 `some_tag("string")` 改为 `dynamic_tag()`，因为 `turn-tag` 在运行时接受 tag/symbol/string，旧签名在 `tag?` 窄化后误报
-
-## 知识点
-
-1. **双向窄化**：`if (nil? x) ... else ...`，false 分支可从 `Optional(T)` 解包为 `T`，这在链式 if 模式中可以传播类型信息
-2. **新窄化暴露的类型签名问题**：`tag?` 窄化后，`(turn-tag x)` 触发了 arg-type-mismatch 警告，因为 `turn-tag` 签名过严。类似 coercion 函数应使用 `dynamic_tag()`
-3. **核心库中 `if (tag? ...)` 出现 5 次、`if (nil? ...)` 26 次、`if (list? ...)` 41 次**——窄化覆盖面广
-4. **JS 端 tuple `.nth` 缺失**：prior session 简化了多态函数（移除 tuple? 分支），但 JS runtime 的 `invoke_method` 没有对应的 core-tuple-methods 注册，导致 JS 测试 `test_refs` 失败。这是 JS procs 层的问题，不是预处理阶段的问题
-
-## 测试结果
-
-- Rust: 246 tests pass（67 cirru + 179 unit）
-- Clippy: clean
-- JS: 已知 pre-existing failure（tuple .nth in JS runtime）

package/editing-history/2026-04-17-0132-monomorphize-map-filter.md

@@ -1,50 +0,0 @@
-# Monomorphize `map` / `filter` at Compile Time
-
-## 背景
-
-`try_specialize_polymorphic_call`（`src/runner/preprocess/mod.rs`）原本只能把
-`count`、`empty?`、`first`、`rest`、`nth`、`get`、`assoc`、`contains?` 等
-**built-in 多态 proc** 特化成 native proc（`NativeListCount` / `NativeMapGet`
-等），彻底避免运行时按 `type_of` 做分支。
-
-但是 Calcit 里最常见的集合高阶函数 `map` / `filter` / `reduce` 等都是在
-`calcit-core.cirru` 里用 Calcit 本身定义的用户级 defn（例如 `&list:map`、
-`&map:map`、`&set:filter`），原先不能在预处理阶段复用这套机制，运行时仍要靠
-`list?`/`map?`/`set?` 三条 `cond` 分支来分发。
-
-本次把能力扩展到 Calcit 级别的 core def，当 receiver 的静态类型可推断时，
-直接把 `(map xs f)` 改写成 `(calcit.core/&list:map xs f)` 等形式。
-
-## 关键改动
-
-- `src/runner/preprocess/mod.rs`
-  - `try_specialize_polymorphic_call` 新增 `file_ns: &str` 参数，用于构造
-    `Calcit::Import` 头的 `ImportInfo::Core { at_ns }`。
-  - 在已有的 proc 特化表之前新增一张“core def 特化表”：
-    - `("map", List(_))   -> &list:map`
-    - `("map", Map(_, _)) -> &map:map`
-    - `("filter", List(_))   -> &list:filter`
-    - `("filter", Map(_, _)) -> &map:filter`
-    - `("filter", Set(_))    -> &set:filter`
-  - 命中时直接构造 `Calcit::Import(CalcitImport { ns: "calcit.core", def, info:
-    Core { at_ns: file_ns }, def_id: Some(program::ensure_def_id(...).0) })`
-    作为新的 head，保持已 preprocess 过的参数不变，避免重复预处理。
-  - 禁止对 `&list:map` / `&map:map` / `&set:map` / `&list:filter` /
-    `&map:filter` / `&set:filter` 自身再次 monomorphize，避免潜在 cycle。
-  - 调用点 `Ok(Calcit::from(CalcitList::from(ys)))` 前的 specialize 调用传入
-    `file_ns`。
-
-## 验证
-
-- `cargo fmt && cargo clippy --release -- -D warnings` ✓
-- `cargo test --release` ✓ 所有现有测试通过
-- `yarn check-all` ✓ 全量集成测试 + WASM 测试全部 OK
-
-## 后续思路
-
-- 可继续把 `reduce` / `last` / `reverse` / `concat` / `to-list` / `to-set`
-  等也加入特化表；其中 `concat` / `reverse` 已有 native proc（`NativeListConcat`
-  / `NativeListReverse`），加到已有 proc 表即可。
-- 可以考虑把谓词（`list?`、`map?`、`number?`、`string?` …）在类型已知时直接折叠成
-  `true` / `false`，进一步帮 WASM / JS codegen 消冗余分支。
-- 未来 `&set:map` 如果单独实现，即可补齐 `("map", Set(_))` 分支。

package/editing-history/2026-04-17-0135-monomorphize-includes-reverse.md

@@ -1,31 +0,0 @@
-# Monomorphize `includes?` and `reverse`
-
-## 背景
-
-继 `map` / `filter` 之后，继续扩展 `try_specialize_polymorphic_call`：
-
-- `includes?` 原实现（calcit-core.cirru L3228）有 5 条 `if` 分支
-  （`nil?` / `list?` / `map?` / `set?` / `string?` fallback `.includes?`）。
-- `reverse` 实际上在 runtime 就是 `&list:reverse` 的别名，但以前每次调用还是要
-  经过一层 Calcit user-def 间接。
-
-## 改动
-
-在 `src/runner/preprocess/mod.rs` 的 proc 特化表中追加：
-
-```text
-("includes?", T::List(_))   -> NativeListIncludes
-("includes?", T::Map(_, _)) -> NativeMapIncludes
-("includes?", T::Set(_))    -> NativeSetIncludes
-("includes?", T::String)    -> NativeStrIncludes
-("reverse",   T::List(_))   -> NativeListReverse
-```
-
-`concat` 因为是变长参数 defn，暂不在这里处理；后续可以在 preprocess 阶段
-把已知都是 list 的 `(concat a b)` 展开为 `(&list:concat a b)` 的折叠形式。
-
-## 验证
-
-- `cargo fmt && cargo clippy --release -- -D warnings` ✓
-- `cargo test --release` ✓
-- `yarn check-all` ✓

package/editing-history/2026-04-17-0140-fold-type-predicates.md

@@ -1,44 +0,0 @@
-# Fold type predicates when static type is known
-
-## 背景
-
-`list?` / `map?` / `set?` / `string?` / `number?` / `bool?` / `tag?` / `fn?` /
-`tuple?` / `record?` 这些 type predicate defn 都是 `(&= (type-of x) :xxx)`
-的形式。如果 preprocess 能拿到 `x` 的静态类型，整个调用就可以折叠成一个字面的
-`true` 常量（或者保留运行时 check，但不把 `false` 折叠以保持安全）。
-
-在 WASM / JS codegen 场景下这尤其有收益：谓词出现在 `if` / `cond` 里，
-折叠成常量后整个分支会被后续 dead-code 消除。
-
-## 改动
-
-`src/runner/preprocess/mod.rs::try_specialize_polymorphic_call` 新增一段在
-proc 特化表之前的折叠逻辑：
-
-```rust
-let predicate_true = matches!(
-  (fn_def, receiver_type.as_ref()),
-  ("list?",   T::List(_))
-  | ("map?",    T::Map(_, _))
-  | ("set?",    T::Set(_))
-  | ("string?", T::String)
-  | ("number?", T::Number)
-  | ("bool?",   T::Bool)
-  | ("tag?",    T::Tag)
-  | ("fn?",     T::Fn(_) | T::DynFn)
-  | ("tuple?",  T::Tuple(_) | T::DynTuple)
-  | ("record?", T::Record(_) | T::Struct(_, _))
-);
-if predicate_true { return Some(Calcit::Bool(true)); }
-```
-
-**设计选择**：只折叠“肯定为 true”的情形，不折叠“肯定为 false”的情形。
-原因：`CalcitTypeAnnotation` 枚举有 30+ variant（包括 `Optional`、`Ref`、
-`TypeVar`、`TypeRef`、`Trait` 等等），要列全“除此之外的全部”枚举会很脆弱、
-以后新增 variant 容易漏。保留 runtime check 是安全的 fallback。
-
-## 验证
-
-- `cargo fmt && cargo clippy --release -- -D warnings` ✓
-- `cargo test --release` ✓（179 + 67 测试全通过）
-- `yarn check-all` ✓

package/editing-history/2026-04-17-0154-generic-dispatch-records-tuples.md

@@ -1,52 +0,0 @@
-# Extend generic assoc/nth/get/count/contains?/empty?/first to records & tuples
-
-## 背景
-
-Recollect 升级到 `defstruct` + `%{}` 构造记录后，在 JS 运行时调用 `assoc` /
-`nth` / `get` 等会 fallback 到 `.method`，再经过 `invoke_method` 在
-`structRef.impls` 中查找；但默认构造的 struct 并没有自动挂上 core 的
-`:assoc` / `:nth` / `:get` impls，导致 `Error: No implementation for ... to
-lookup .assoc` 等。
-
-Rust 解释器路径能自动解析到 `&record:*` 内置 proc，所以 `cr --entry test`
-能跑过，但 JS 输出（`cr js` + Node）跑不过。
-
-## 改动
-
-在 `src/cirru/calcit-core.cirru` 的若干 generic 分发函数里显式增加
-`record?` / `tuple?` 分支，直接路由到内置 proc，不再依赖 method lookup：
-
-| 函数        | 新增分支                                                 |
-| ----------- | -------------------------------------------------------- |
-| `assoc`     | `record? -> &record:assoc`, `tuple? -> &tuple:assoc`      |
-| `nth`       | `tuple? -> &tuple:nth`, `record? -> &record:nth`          |
-| `get`       | `tuple? -> &tuple:nth`, `record? -> &record:get`          |
-| `count`     | `tuple? -> &tuple:count`, `record? -> &record:count`      |
-| `contains?` | `record? -> &record:contains?`                           |
-| `empty?`    | `record? -> (&= 0 (&record:count x))`, tuple 同理         |
-| `first`     | `tuple? -> (&tuple:nth x 0)`                             |
-
-这几处与“运行时按 `type-of` 分支”的方向是一致的——在当前 Calcit 语义下
-records / tuples 是独立 kind，本来就应该在 generic 分发里显式处理，而不是
-掉到“最后一条 method lookup” 的兜底里。
-
-与此前添加的 **编译期单态化**（`try_specialize_polymorphic_call`）是互补的：
-当静态类型已知时在预处理阶段直接改写成 proc 调用；静态类型未知时，运行时
-分支也能正确分发到 `&record:*` / `&tuple:*`，而不再需要结构实现端配合
-impls。
-
-## 验证
-
-- `cargo fmt && cargo clippy --release -- -D warnings` ✓
-- `cargo test --release` ✓（179 + 67 全过）
-- `yarn check-all` ✓
-- recollect 全套：
-  - `cr --entry test` ✓
-  - `cr --entry test js && env=ci node test.mjs` ✓（此前 `.assoc` 报错修复）
-  - `cr js && yarn vite build --base=./` ✓
-
-## 后续
-
-随着 Calcit 继续演进，这些 chain-of-if 分发仍然是临时形态。更彻底的做法是
-在预处理阶段通过类型推断消除所有 generic 分发 defn，让核心库只暴露
-`&list:*` / `&map:*` / `&record:*` 等单态 proc —— 见下一步语言简化计划。

package/editing-history/2026-04-17-0520-simplify-generic-defns-via-method-dispatch.md

@@ -1,49 +0,0 @@
-# Simplify generic core defns via `.method` dispatch
-
-## 概要
-
-将 `calcit-core.cirru` 中的泛型 defn（`assoc` / `contains?` / `count` / `empty` / `empty?` / `filter` / `first` / `get` / `includes?` / `nth` / `rest` / `map`）从多分支 `if (list? x) ... if (map? x) ... if (record? x) ...` 链简化为 `list?` 快速路径 + `.method` 动态分发。
-
-## 动机
-
-- 用户要求：优先使用 `.method` 这套已有概念承担多态分发，避免每新增类型（record / tuple / set 等）都要在每个 defn 中追加分支。
-- 所有 built-in 类型已在 `&core-*-methods` 中注册了对应的 `.assoc` `.count` `.empty?` `.get` `.nth` 等方法条目，编译期 `try_inline_method_call` 已能在静态类型已知时把方法调用内联为直接 proc 调用，runtime 则由 `invoke_method` 处理。这使得 defn 自身不再需要枚举类型。
-
-## 实现
-
-以 `empty?` 为例：
-
-```cirru
-defn empty? (x)
-  if (nil? x) true $ if (list? x) (&list:empty? x) (.empty? x)
-```
-
-保留 `nil?` 与 `list?` 两个前置分支，其余类型全部交给 `.empty?`。
-
-**为什么保留 `list?` 快速路径**：
-`ensure_ns_def_compiled(CORE_NS, &init-builtin-impls!)` 在预处理期会展开 `do` 等 macro，其中 `(empty? body)` 会在 impls 还未注册到 runtime 时被调用；若此时 `empty?` 体里就走 `.empty?` → `invoke_method` → `evaluate_symbol_from_program("&core-list-impls", ...)` 会命中 quick-path 失败（循环依赖），导致 panic：
-
-```
-preprocess builtin impls: CalcitErr { kind: Var, msg: "expected symbol `&core-list-impls` from path `calcit.core`, this is a quick path, should succeed", ... }
-```
-
-`list?` 本身只用 `(&= (type-of x) :list)` 等 proc，不依赖 impl 注册，能在 bootstrap 期安全使用，打破循环；其余类型的 methods 此时已构建完毕，可顺利走方法派发。
-
-## 波及范围
-
-- `src/cirru/calcit-core.cirru`：12 个 defn 的 body 瘦身。
-- 预处理期的 `try_specialize_polymorphic_call`（已有）照常将 `(assoc x k v)` 等静态可推断调用折叠为 `&list:assoc`/`&map:assoc` 等 proc。
-- runtime 侧未变：仍由 `invoke_method` + `&core-*-impls` 完成最终派发。
-
-## 验证
-
-- `cargo fmt`
-- `cargo clippy --release -- -D warnings`
-- `cargo test --release`：179 + 67 通过
-- `yarn check-all`：全部 WASM/JS/解释执行测试通过
-- recollect (`cr --entry test` + `cr --entry test js` + `node test.mjs`) ✓
-- respo (`cr --check-only` + `cr js` + `yarn vite build`) ✓
-
-## 备注
-
-- 下一步可以考虑：把那些只剩 `list?` 单分支的 defn 再收拢到一个运行时 primitive，或在 preprocess 阶段对 macro 展开期调用的 `empty?` 等函数强制内联 proc，从而彻底去掉这条 fast path。

package/editing-history/2026-05-21-0055-tree-show-cr-config-and-edit-cleanup.md

@@ -1,81 +0,0 @@
-# 202605210055 — tree show 可选路径 + cr config 顶级命令 + cr edit 清理
-
-## 修改概要
-
-### 1. `cr tree show` — `-p` 参数改为可选，缺失时警告而非报错
-
-**动机**: Agent 调用 `cr tree show ns/def` 时若忘记 `-p`，原来直接报错导致 token 浪费。
-
-**变更文件**:
-
-- `src/cli_args.rs`: `TreeShowCommand.path` 类型从 `String` → `Option<String>`，doc 注释更新
-- `src/bin/cli_handlers/tree.rs`: `handle_show` 中对 `None` 输出黄色 `[Warn]`，默认使用空路径（root）
-- `src/bin/cli_handlers/command_echo.rs`: `push_tree` Show 分支改用 `opt "path"` 宏处理 Option 类型
-
-**效果**:
-
-```
-$ cr calcit.cirru tree show "ns/def"
-[Warn] No path (-p) specified; showing from root. Use -p '0' to start from a child node.
-Type: list (4 items)
-...
-```
-
----
-
-### 2. `cr config` — 顶级配置管理命令
-
-**动机**: `cr query config`、`cr query modules`、`cr edit config`、`cr edit add-module`、`cr edit rm-module` 分散在不同子命令下，操作配置需要记忆多个入口。新增统一入口 `cr config`。
-
-**新命令**:
-| 命令 | 等价旧命令 |
-|---|---|
-| `cr config show` | `cr query config` |
-| `cr config modules` | `cr query modules` |
-| `cr config version [value]` | `cr edit config version ...` |
-| `cr config set <key> <value>` | `cr edit config <key> <value>` |
-| `cr config add-module <path>` | `cr edit add-module <path>` |
-| `cr config rm-module <path>` | `cr edit rm-module <path>` |
-
-`cr config version` 可独立使用（无参数显示当前版本，传 `patch/minor/major` 递增，传 semver 直接设置）。
-
-**变更文件**:
-
-- `src/cli_args.rs`: 添加 `CalcitCommand::Config`、`ConfigCommand`、`ConfigSubcommand`（含 `ConfigVersionCommand`）及各子命令 struct
-- `src/bin/cli_handlers/config.rs`: 新建，实现 `handle_config_command` 及各子命令处理函数（含 `handle_version`）
-- `src/bin/cli_handlers/edit.rs`: `parse_semver_value`、`bump_semver_value` 改为 `pub(crate)`
-- `src/bin/cli_handlers/mod.rs`: 注册 `mod config` 并 re-export `handle_config_command`
-- `src/bin/cli_handlers/command_echo.rs`: 添加 `config_name`、`push_config`，并在 `should_echo_command` / `render_command_echo` 中处理 `Config` 变体
-- `src/bin/cr.rs`: 添加 `CalcitCommand::Config` 分支
-
----
-
-### 3. `cr edit` 清理 — 移除已迁移至 `cr config` 的子命令
-
-**动机**: `cr edit add-module`、`cr edit rm-module`、`cr edit config` 与新增的 `cr config` 重复，保持单一职责。
-
-**删除内容**:
-
-- `EditSubcommand::AddModule / RmModule / Config` 及对应 struct（`cli_args.rs`）
-- `handle_add_module / handle_rm_module / handle_config` 函数体（`edit.rs`）
-- `command_echo.rs` 中 `edit_name` 和 `push_edit` 两处 match 的三个变体
-
-**保留**（被 `config.rs` 和单元测试引用）:
-
-- `pub(crate) fn parse_semver_value` — semver 字符串解析
-- `pub(crate) fn bump_semver_value` — patch/minor/major 递增
-
-**文档更新**:
-
-- `docs/run/agent-advanced.md` "模块和配置" 章节、快速参考示例 → 全部改为 `cr config` 命令
-- `docs/CalcitAgent.md` 第 9 节"cr 能力地图" → 新增"配置管理"条目
-
----
-
-## 知识点
-
-- `argh` 中将 `#[argh(option)]` 字段类型改为 `Option<T>` 可使该选项变为可选
-- `pub(crate)` 可在同一 crate 内跨模块共享；被其他模块引用时，不能因删除调用方而一并删除
-- 新增顶级命令时需同步更新 `command_echo.rs` 的三处：`should_echo_command`、`render_command_echo`（名称映射和 token push）
-- 移除 enum 变体时，需同时检查 `command_echo.rs` 的两处 match（`edit_name` 和 `push_edit`）
-- 单元测试也会引用函数，删除前要 grep `tests` 模块确认

package/editing-history/2026-05-31-2052-macro-schema-roundtrip-and-weak-types.md

@@ -1,6 +0,0 @@
-- refined weak-types reporting in `cr analyze weak-types` to classify schema/code hits with detail paths
-- tightened builtin proc signatures for list/map/set/buf-list helpers toward generic compound types
-- kept `field-match` / `record-match` macro schema inputs precise in `calcit-core` while preserving round-trip behavior
-- fixed macro schema serialization to keep non-dynamic returns like `:record` instead of dropping them during snapshot save/load
-- aligned bare marker tag parsing for `:record` and related special tags with schema normalization behavior
-- updated docs and parser tests to current wrapped schema / guidebook-loading behavior

package/editing-history/2026-05-31-2105-map-generic-weak-types-followup.md

@@ -1,15 +0,0 @@
-- tightened multiple calcit.core snapshot schemas that safely remove weak composite internals without narrowing runtime behavior: typed path lists for `assoc-in`/`get-in`/`dissoc-in`/`update-in`/`contains-in?`, typed collection helpers like `apply`, `join-str`, `foldr-shortcut`, and explicit output map generics for `map-kv` and `pairs-map`
-- corrected one weak-types false lead by changing `keys` from returning `:list` to `:set`, matching runtime/tests and moving that hit out of the list family
-- extended `cr analyze weak-types` to classify nested schema-dynamic shapes/families, include per-definition summaries, split family/shape counts by `arg`/`return` position, and show per-definition `shape@position` contributors for the remaining hotspots
-- confirmed the current lower-bound weak hits under the existing type system: `&record:to-map` for heterogeneous record values; `&tuple:params`, `&cirru-quote:to-list`, `parse-cirru-list`, `&format-ternary-tree`, `&list:flatten`, `format-cirru`, and `format-cirru-one-liner` for mixed list payloads that cannot be soundly collapsed to `list<'T>`
-- verified the final baseline at schema-dynamic=290 with `cargo test --bin cr analyze_weak_types -- --nocapture`, repeated `cargo run --bin cr -- calcit/test.cirru analyze weak-types --ns calcit.core --only schema-dynamic`, and runtime suite checks via `cargo run --bin cr -- calcit/test.cirru`
-- aligned `parse-float` runtime behavior with the existing optional-number schema across Rust and JS: invalid input now yields `nil`/`null` instead of throwing or leaking `NaN`, and added inference coverage in `calcit/test-types-inference.cirru`
-- aligned JS record missing-field behavior with Rust/eval by making `CalcitRecord.get` return `undefined` on absent fields, which keeps top-level `get` and `get-in` optional semantics consistent across runtimes
-- refined preprocess return inference for `calcit.core/get` and `calcit.core/get-in`, so list/string/map/record accesses produce precise `optional<...>` results for literal paths instead of collapsing to broad `dynamic` in the common safe cases
-- tightened the generic matching path so `Struct` annotations and bare `TypeRef` names bind declared type variables consistently when only one side carries applied type arguments, reducing a gap that previously skipped bindings needed by later generic specialization and `:where` checks
-- validated the follow-up with `cargo run --bin cr -- calcit/test-types-inference.cirru`, `cargo test binds_generic_args_from`, `cargo fmt && cargo test binds_generic_args_from`, and `yarn try-rs`
-- added RFC `RFCs/06-01-generic-binding-unification-rfc.md` to document the next step for Rust-like generic binding unification across `Struct` / `Enum` / `TypeRef`, including concrete examples, rollout stages, and the tradeoff that enum support needs deeper metadata changes than the struct-side fix
-- extended the enum-generic foundation end to end: runtime enum metadata now preserves declared generics, `&enum::new` accepts generic parameter lists, and applied named enum annotations like `(:: 'ResultX :number :string)` validate against payload creation instead of being rejected as "enum cannot be generic"
-- fixed the remaining struct declaration gap in the core macros/runtime boundary: `defstruct Box ([] 'T) (:value 'T)` now lowers to a real generics list for `&struct::new`, and generic field annotations are preserved as type forms instead of being evaluated away before runtime parsing
-- documented the current runnable generic data-structure entry points in `docs/features/records.md` and `docs/features/enums.md`, including a high-level generic `defstruct` example and the current stable generic-enum constructor form via `&enum::new`
-- validated the new docs/examples with direct eval smoke checks for the struct and enum snippets, `cargo run --bin cr -- demos/calcit.cirru docs check-md docs/features/records.md`, `cargo run --bin cr -- demos/calcit.cirru docs check-md docs/features/enums.md`, and `cargo run --bin cr -- calcit/test-generics.cirru`

package/editing-history/2026-06-01-0003-update-callback-field-specialization.md

@@ -1,19 +0,0 @@
-# 2026-06-01 00:03 update callback field specialization
-
-## Summary
-
-- specialized `calcit.core/update` call checking so the 3rd callback arg can inherit a known record/struct field type instead of always staying at generic `fn('T) -> 'T`
-- fixed record field inference to resolve `TypeRef`-based struct annotations, not only direct `Record`/`Struct` annotations
-- aligned native `not` proc signature with calcit-core semantics by accepting dynamic input and returning `:bool`
-
-## Why
-
-- `respo` used precise type refs like `'respo.app.schema/Task`, but `infer_record_field_type` only looked through direct `Record`/`Struct` annotations, so `update task :done? not` could not see the field type
-- even after specializing `update`, Rust-side proc metadata still described `not` as `fn(:bool?) -> :bool`, which was stricter and inconsistent with the core schema/docs path
-
-## Validation
-
-- `cargo test specialize_update_uses_record_field_type_for_callback`
-- `cargo run --manifest-path /Users/chenyong/repo/calcit-lang/calcit/Cargo.toml --bin cr -- js` from `respo`
-- `yarn try-rs`
-- `cargo test`

package/editing-history/2026-06-01-2317-data-definition-where-bounds.md

@@ -1,6 +0,0 @@
-- added where-bound metadata to struct and enum definitions, preserving it through parsing, hashing, compare, serialization, and enum prototype reconstruction
-- enforced data-definition generic trait bounds at runtime for `%{}`, `%{}?`, and `%::` by inferring concrete type bindings from record fields and enum payloads
-- kept builtin `Show` satisfaction narrow to builtin value families so function-level missing-impl warnings still fire correctly during preprocess
-- covered the new runtime path with focused Rust tests for accepting and rejecting struct/enum payloads under generic where-bounds
-- validated the calcit side with `cargo test where_bounds --lib`, `yarn check-all`, release `cr` build, and downstream respo compilation via `../../calcit-lang/calcit/target/release/cr js`
-- downstream follow-up in respo needed one explicit `assert-type text :string` for the `Op::update` payload under the stricter enum payload check