@calcit/procs 0.11.0-a9 → 0.11.1

package/.gitattributes

@@ -3,3 +3,4 @@ calcit.cirru -diff linguist-generated
 yarn.lock -diff linguist-generated
 Cargo.lock -diff linguist-generated
 lib -diff linguist-generated
+editing-history -diff linguist-generated

package/build.rs

@@ -0,0 +1,74 @@
+use cirru_edn::{Edn, from_edn};
+use cirru_parser::Cirru;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::env;
+use std::fs;
+use std::path::Path;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SnapshotConfigs {
+  #[serde(rename = "init-fn")]
+  pub init_fn: String,
+  #[serde(rename = "reload-fn")]
+  pub reload_fn: String,
+  #[serde(default)]
+  pub modules: Vec<String>,
+  #[serde(default)]
+  pub version: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CodeEntry {
+  pub doc: String,
+  #[serde(default)]
+  pub examples: Vec<Cirru>,
+  pub code: Cirru,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct FileInSnapShot {
+  pub ns: CodeEntry,
+  pub defs: HashMap<String, CodeEntry>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Snapshot {
+  pub package: String,
+  pub about: Option<String>,
+  pub configs: SnapshotConfigs,
+  pub entries: HashMap<String, SnapshotConfigs>,
+  pub files: HashMap<String, FileInSnapShot>,
+}
+
+fn main() {
+  println!("cargo:rerun-if-changed=src/cirru/calcit-core.cirru");
+
+  let out_dir = env::var_os("OUT_DIR").unwrap();
+  let dest_path = Path::new(&out_dir).join("calcit-core.rmp");
+
+  let core_content = fs::read_to_string("src/cirru/calcit-core.cirru").expect("read core");
+  let core_data = cirru_edn::parse(&core_content).expect("parse core");
+
+  // Minimal logic to convert Edn to Snapshot as in src/snapshot.rs
+  let data = core_data.view_map().expect("map");
+  let pkg: String = from_edn(data.get_or_nil("package")).expect("pkg");
+  let about = match data.get_or_nil("about") {
+    Edn::Nil => None,
+    value => Some(from_edn::<String>(value).expect("about")),
+  };
+
+  let files: HashMap<String, FileInSnapShot> = from_edn(data.get_or_nil("files")).expect("files");
+
+  let snapshot = Snapshot {
+    package: pkg,
+    about,
+    configs: from_edn(data.get_or_nil("configs")).expect("configs"),
+    entries: from_edn(data.get_or_nil("entries")).expect("entries"),
+    files,
+  };
+
+  let mut buf = Vec::new();
+  snapshot.serialize(&mut rmp_serde::Serializer::new(&mut buf)).expect("serialize");
+  fs::write(dest_path, buf).expect("write");
+}

package/editing-history/2026-0213-1841-trait-origin-structural-eq.md

@@ -0,0 +1,91 @@
+# 202602131841 trait origin 匹配与结构化 trait 相等性
+
+## 背景
+
+本次提交延续了动态方法告警收敛与 trait 分发可靠性改进。
+评审中提出的核心问题是：trait 分发不应只依赖 trait 名称匹配。
+`impl` 记录本身已经携带了 trait 的 origin 元数据，因此匹配应直接基于 origin。
+
+## 目标
+
+1. 让 `&trait-call` 按 trait origin 相等性选择 impl，而不是按名称字符串匹配。
+2. 让 trait/impl 的相等语义与上述运行时选择模型一致。
+3. 在尽量保持兼容的前提下，提高歧义/重名场景下的正确性。
+4. 保持现有优先级规则不变（用户 impl：后者覆盖前者；内建 impl：前者优先）。
+
+## 思考过程
+
+### 为什么 name-only 匹配不够
+
+- 仅按名称匹配会把“同名但结构不同”的 trait 混为一类。
+- 运行时已有 `CalcitImpl.origin: Option<Arc<CalcitTrait>>`，若忽略它会浪费已有语义信息。
+- 使用显式 `&trait-call` 时，调用方预期的是“精确 trait 命中”，而非按名字近似匹配。
+
+### 分发策略决定
+
+在 `trait_call` 中：
+
+- 旧逻辑：`imp.trait_name()` 与 `trait_def.name` 比较。
+- 新逻辑：`imp.origin()` 与目标 trait 直接通过 `Eq` 比较。
+
+该方案改动小、语义清晰，并与当前运行时模型一致，不引入额外解析复杂度。
+
+### Eq/Hash 一致性
+
+当分发切换到 origin 相等后，`CalcitTrait` 的相等语义就不能继续只看 `name`。
+
+因此将 `CalcitTrait` 的 Eq/Hash 升级为结构化比较，包含：
+
+- trait 名称
+- 方法名列表
+- 方法类型签名
+- requires（依赖 trait）
+- 默认实现槽位形状（每个位置是 `Some` 还是 `None`）
+
+关于默认实现：
+
+- 默认函数体（`CalcitFn`）不做深比较/深哈希，因为 `CalcitFn` 当前不提供完整 Eq/Hash。
+- 这里只比较默认槽位可用性形状，以保证 Eq/Hash 契约一致，同时提升结构判断准确性。
+
+## 文件级改动
+
+### 运行时分发与文档
+
+- `src/builtins/meta.rs`
+  - `trait_call` 改为按 `impl.origin` 相等匹配。
+  - 同步更新函数附近注释，确保文档与实现一致。
+
+### impl 相等性
+
+- `src/calcit/calcit_impl.rs`
+  - `PartialEq` 改为直接比较 `origin`（不再只比较 `origin.name`）。
+
+### trait 相等性与哈希语义
+
+- `src/calcit/calcit_trait.rs`
+  - `PartialEq` 从 name-only 改为结构化比较。
+  - `Hash` 同步到相同结构维度。
+  - 增加注释，说明默认函数比较策略。
+
+### 相关一致性修正（同一工作区变更）
+
+- `src/runner/preprocess.rs`
+  - 修复重命名后的测试守卫符号残留（`DynTraitCheckGuard` -> `WarnDynMethodGuard`）。
+
+## 验证
+
+- `cargo fmt`
+- `cargo test -q`
+  - 结果：当前工作区下测试全部通过。
+
+## 兼容性与风险
+
+- 该行为变化是有意为之：同名但结构不同的 trait 不再被视为相等。
+- 默认函数体差异仍不纳入 Eq/Hash。
+- 方法分发优先级规则保持不变。
+
+## 后续可选项
+
+1. 如有需要，可补强默认实现身份比较（例如优先比较 def ref）。
+2. 增加“同名不同结构 trait”相等性的显式测试用例。
+3. 继续收敛 `warn-dyn-method` 全量运行中的剩余动态调用告警。

package/editing-history/2026-0213-1926-docs-tests-followup.md

@@ -0,0 +1,33 @@
+# 2026-02-13 19:26 文档与测试补充（跟进）
+
+## 背景
+
+在完成 trait/macro 相关优化（P1/P2/P3）后，补做“是否需要补充测试与文档”的审计。
+
+## 本次结论
+
+需要补充，且已补最小必要范围：
+
+1. 文档：
+   - `guidebook/docs/features/macros.md`
+     - 增加 `with-gensyms` 用法示例。
+     - 增加 `macroexpand`/`macroexpand-1`/`macroexpand-all` 的展开链路说明（stderr）。
+   - `guidebook/docs/features/traits.md`
+     - 增加 `warn-dyn-method` 下的新增诊断说明。
+     - 明确 `&trait-call` 按 impl 的 trait origin 匹配，而非仅按名称文本匹配。
+
+2. 测试：
+   - `src/calcit/calcit_trait.rs`
+     - 新增 default identity 单测：
+       - `def_ref` 相同 => trait 相等且 hash 一致；
+       - 无 `def_ref` 时走函数元信息 fallback，并校验等价/不等价边界。
+
+## 验证
+
+- `cargo test -q calcit_trait::tests` 通过。
+- `yarn check-all` 通过（本轮补丁后再跑）。
+
+## 经验点
+
+- 文档应及时反映“诊断开关”边界（默认流程 vs `warn-dyn-method`）。
+- identity 规则变化必须配对 hash/eq 回归测试，避免后续 refactor 引入行为漂移。

package/editing-history/2026-0214-2050-js-codegen-recursion-tag-migration.md

@@ -0,0 +1,39 @@
+# 2026-02-14 20:50 JS codegen recursion + tag migration
+
+## 背景
+
+在 trait/macro 改进后，继续针对 JavaScript 编译目标做性能与可维护性优化。
+
+## 本次改动
+
+1. 参数个数报错模板统一
+
+- 在 runtime 新增 `_args_fewer_throw` / `_args_between_throw`，保留 `_args_throw`。
+- emitter 中 `too few/too many` 模板改为调用统一 helper，错误信息继续携带期望与实际参数个数。
+
+2. rest 参数处理优化
+
+- 对 `&` rest 参数，仅在函数体实际引用时才注入 `arrayToList` 转换，避免不必要转换。
+- 修复符号引用检测边界：`contains_symbol` 增加 `Calcit::Local` 分支。
+
+3. tail recursion 模板优化
+
+- watchdog 从每轮检查改为周期检查（`(times & 1023) === 0` 时再判断上限）。
+- 对无 rest/optional 的固定参数函数，recur 回填改为索引赋值（`arg = ret.args[i]`），减少解构开销。
+
+4. tag 初始化一次迁移
+
+- runtime 新增 `init_tags` 与全局 tag 缓存。
+- emitter 统一改为 `const _t_ = init_tags([...])` / `$clt.init_tags([...])`。
+- 移除每模块内联 `forEach + newTag` 初始化模板。
+- 修复 `calcit.core` 目标缺失导入，补上 `init_tags` import。
+
+## 验证
+
+- `yarn check-all` 通过。
+- 额外执行了 JS 微基准（`test-recursion.main/test_loop`）用于观察 recursion 模板优化影响。
+
+## 经验点
+
+- JS 生成模板优化要先保证语义完整，再做结构性收敛（helper 化/去重复）。
+- 对 codegen 的性能优化，建议配套微基准，并与 baseline 做同脚本对比。

package/editing-history/2026-0214-2358-emit-js-modularization-shift-left.md

@@ -0,0 +1,63 @@
+# 2026-02-14 23:58 emit_js modularization + shift-left contracts
+
+## Scope
+
+This round focuses on two tracks:
+
+1. Continue low-risk modularization of `src/codegen/emit_js.rs` without changing runtime semantics.
+2. Introduce AI-oriented "shift-left" validation contracts for expected warning/error paths.
+
+## What changed
+
+### Rust codegen modularization
+
+- Removed duplicate legacy module file:
+  - `src/calcit/struct.rs`
+- Split helpers from `emit_js.rs` into cohesive submodules:
+  - `src/codegen/emit_js/tags.rs`
+  - `src/codegen/emit_js/symbols.rs`
+  - `src/codegen/emit_js/paths.rs`
+  - `src/codegen/emit_js/runtime.rs`
+  - `src/codegen/emit_js/args.rs`
+  - `src/codegen/emit_js/deps.rs`
+  - `src/codegen/emit_js/helpers.rs`
+- Kept behavior stable by only moving logic and wiring imports/call sites.
+- Added targeted unit tests in extracted modules.
+
+### Runtime helper boundary cleanup (TS)
+
+- Grouped runtime helpers into dedicated modules:
+  - `ts-src/js-arity-helpers.mts` (`_args_throw`, `_args_fewer_throw`, `_args_between_throw`)
+  - `ts-src/js-tag-helpers.mts` (`init_tags` + internal cache)
+- Switched `ts-src/calcit.procs.mts` to re-export these modules, keeping public API names unchanged.
+
+### Test/validation workflow improvements
+
+- Added contract-based shift-left script:
+  - `scripts/check-shift-left.mjs`
+- Added npm script:
+  - `check-shift-left` in `package.json`
+- This script enforces both:
+  - positive baseline must pass (`calcit/test.cirru -1`)
+  - selected negative cases must fail with expected diagnostic tokens.
+
+### Planning/documentation updates
+
+- Expanded and updated roadmap status:
+  - `drafts/project-modernization-roadmap.md`
+- Added AI-oriented long-term section for:
+  - immutable core constraints
+  - earlier error detection
+  - contractized diagnostics
+  - staged execution strategy.
+
+## Verification
+
+- Ran targeted unit tests for extracted modules (`tags/symbols/paths/runtime/args/deps/helpers` where applicable).
+- Repeated full validation with `yarn check-all` after each refactor batch.
+- Ran `yarn check-shift-left` to validate diagnostic contracts.
+
+## Notes
+
+- Some standalone `calcit/test-*.cirru` files are intentionally warning/error reproductions or independent package entries; they are not safe to inline into `test.cirru` module list directly.
+- Using a separate shift-left contract script avoids namespace collisions and preserves intent.

package/editing-history/2026-0215-1941-macro-diagnostics-refinement.md

@@ -0,0 +1,39 @@
+# Macro Diagnostics Refinement (2026-02-15 19:41)
+
+## Summary
+
+This change improves diagnostic quality for macro misuse and warning flows without changing macro semantics.
+
+## Key updates
+
+- Added a shared diagnostics helper module:
+  - `src/diagnostics_help.rs`
+  - Centralizes message-to-help inference logic.
+- Improved stack-rendered failure guidance:
+  - `src/call_stack.rs`
+  - Uses macro-context-aware help text.
+  - Keeps examples targeting user-facing macros over internal helper macros.
+- Improved warning-path guidance:
+  - `src/bin/cr.rs`
+  - Reuses shared help inference for preprocessing/codegen warning blocks.
+- Improved macro argument binding diagnostics in runtime:
+  - `src/runner.rs`
+  - Replaces low-level `Idx(...)` style arity failures with readable signatures and missing argument names.
+- Refined macro-side error wording:
+  - `src/cirru/calcit-core.cirru`
+  - Better `list-match` branch-shape messages.
+- Kept macro signatures intact where requested:
+  - `when`, `when-not`, `when-let` remain with explicit parameter forms.
+
+## Validation
+
+- Spot checks executed with `cr eval` for macro misuse cases:
+  - `when`, `when-not`, `when-let`, `if-not`, `tag-match`, `record-match`, `list-match`, `cond`, `let`, `thread-first`, `thread-last`.
+- Confirmed help text differentiates macro misuse vs proc/function arity warnings.
+- Full regression passed:
+  - `yarn check-all` => `EXIT:0`.
+
+## Notes
+
+- This iteration focuses on user-facing diagnostics quality.
+- Behavior and compatibility are preserved; changes are primarily in error/help reporting paths.

package/editing-history/2026-0215-diagnostics-consolidated.md

@@ -0,0 +1,35 @@
+# 2026-02-15 diagnostics 合并记录
+
+本文件合并以下 diagnostics 相关记录，避免碎片化：
+
+- 2026-0215-1011-preprocess-diagnostic-v1.md
+- 2026-0215-1026-cli-diag-json.md
+- 2026-0215-1104-diag-expected-actual-action-let.md
+- 2026-0215-1110-eval-diag-fallbacks.md
+- 2026-0215-1116-macro-diagnostic-protocol.md
+- 2026-0215-1134-macro-diag-expansion-if-defn-assert.md
+- 2026-0215-1152-runtime-fallback-tag-match-arity.md
+- 2026-0215-1202-warning-arity-fallback-compat.md
+- 2026-0215-1211-warning-learning-fields.md
+- 2026-0215-1238-convergence-help-docs-diag.md
+- 2026-0215-1306-text-diagnostics-convergence-fix.md
+- 2026-0215-1332-diagnostics-simplification-example-driven.md
+
+## 合并后的结论（当前保留）
+
+- 已移除 `--diag json` 路径，CLI 统一使用文本诊断输出。
+- warning 维持最小字段与文本展示，不再维护 JSON 结构演进。
+- error 维持 call stack + examples 辅助定位，避免复杂规则映射。
+- 文本模式保持简洁：优先 message/hint/location/stack，便于直接修复。
+
+## 本轮简化（减法）
+
+- 移除 warning 侧复杂增强字段：`fingerprint/convergence/help/learning`。
+- 移除 error 侧复杂增强字段：`fingerprint/convergence/help/learning` 与大段规则映射。
+- 将 error 的 expected/actual/action 处理改为“hint 优先 + 通用 message 提取 + 最小 fallback”。
+
+## 设计原则（后续继续遵循）
+
+- 诊断能力优先复用编译器已有信息（hint、message、stack、examples）。
+- 尽量减少按错误码硬编码规则，避免语言层复杂度膨胀。
+- LLM 修复入口尽量通用化：`query examples` + 最小可执行动作。

package/editing-history/2026-0216-2043-core-api-docs-cleanup.md

@@ -0,0 +1,40 @@
+# 2026-02-16 20:43 core API/docs cleanup
+
+## Scope
+
+- Cleaned outdated draft references and status notes.
+- Aligned core internal API names around trait attachment (`*:impl-traits`).
+- Fixed `wo-js-log` export/definition mismatch.
+- Merged symbol-resolution note into drafts and removed duplicated doc file.
+
+## Key updates
+
+1. **drafts cleanup**
+   - Added `drafts/README.md` as a state index (active/review-needed/archived).
+   - Fixed stale links between `assert-types-plan.md` and `assert-types.md`.
+   - Marked `drafts/last-session.md` as archived historical snapshot.
+
+2. **core naming consistency**
+   - Updated internal entries in `src/cirru/calcit-core.cirru`:
+     - `&record:with-impls` -> `&record:impl-traits`
+     - `&tuple:with-impls` -> `&tuple:impl-traits`
+     - `&struct:with-impls` -> `&struct:impl-traits`
+     - `&enum:with-impls` -> `&enum:impl-traits`
+   - Updated `%::` doc hint to reference `&tuple:impl-traits`.
+
+3. **debug macro fix**
+   - Fixed `wo-js-log` entry to define `wo-js-log` (not `w-js-log`).
+
+4. **symbol note consolidation**
+   - Appended symbol-resolution appendix into `drafts/runtime-traits-plan.md`.
+   - Removed duplicated `docs/symbol-spec.md` after migration.
+
+## Validation notes
+
+- Verified `wo-js-log` evaluates successfully.
+- Verified `&struct:impl-traits` resolves as runtime proc.
+- Confirmed old `&struct:with-impls` now reports unknown symbol (no compatibility layer, by design).
+
+## Follow-up
+
+- If needed, add explicit migration note/changelog entry for removed `*-with-impls` internal names.

package/editing-history/2026-0216-2128-docs-smoke-and-trait-errors.md

@@ -0,0 +1,20 @@
+# Docs smoke cases and trait misuse error normalization
+
+## Summary
+
+- Added executable docs smoke tests for key trait semantics.
+- Integrated smoke tests into main test entry.
+- Normalized high-frequency misuse messages with `Expected/Actual/Fix` guidance.
+- Stabilized cross-runtime smoke assertions so `yarn check-all` passes in both eval and js modes.
+
+## Knowledge points
+
+- `assert-traits` first argument is enforced at preprocess as local-only.
+- `impl-traits` targets definition-level values (`struct`/`enum`), not instances.
+- Error string matching in JS runtime should avoid host-error-dependent formatting; keep strict message-content checks in eval mode.
+
+## Validation
+
+- `cargo fmt`
+- `cargo run --bin cr -- calcit/test.cirru -1`
+- `yarn check-all` (exit code 0)

package/lib/calcit-data.mjs

@@ -291,6 +291,9 @@ export let hashFunction = (x) => {
     if (x instanceof CalcitImpl) {
         let base = defaultHash_impl;
         base = mergeValueHash(base, hashFunction(x.name));
+        if (x.origin != null) {
+            base = mergeValueHash(base, hashFunction(x.origin));
+        }
         for (let idx = 0; idx < x.fields.length; idx++) {
             base = mergeValueHash(base, hashFunction(x.fields[idx]));
             base = mergeValueHash(base, hashFunction(x.values[idx]));
@@ -670,6 +673,12 @@ export let _$n__$e_ = (x, y) => {
             if (x.name !== y.name) {
                 return false;
             }
+            if ((x.origin == null) !== (y.origin == null)) {
+                return false;
+            }
+            if (x.origin != null && y.origin != null && x.origin.name.value !== y.origin.name.value) {
+                return false;
+            }
             if (!fieldsEqual(x.fields, y.fields)) {
                 return false;
             }

package/lib/calcit.procs.mjs

@@ -23,6 +23,8 @@ export * from "./js-tuple.mjs";
 export * from "./js-trait.mjs";
 export * from "./custom-formatter.mjs";
 export * from "./js-cirru.mjs";
+export * from "./js-arity-helpers.mjs";
+export * from "./js-tag-helpers.mjs";
 export { _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList, foldl } from "./js-list.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
@@ -198,14 +200,15 @@ export let defenum = (name, ...variants) => {
     const tags = entries.map((entry) => entry.tag);
     const values = entries.map((entry) => entry.payload);
     const prototype = new CalcitRecord(enumName, tags, values, null);
-    return new CalcitEnum(prototype, null);
+    return new CalcitEnum(prototype);
 };
 export let _$n_impl_$o__$o_new = (name, ...pairs) => {
     if (name === undefined)
         throw new Error("&impl::new expected arguments");
-    const implName = castTag(name);
+    const origin = name instanceof CalcitTrait ? name : null;
+    const implName = origin ? origin.name : castTag(name);
     if (pairs.length === 0) {
-        return new CalcitImpl(implName, [], []);
+        return new CalcitImpl(implName, [], [], origin);
     }
     const entries = [];
     for (let idx = 0; idx < pairs.length; idx++) {
@@ -237,7 +240,7 @@ export let _$n_impl_$o__$o_new = (name, ...pairs) => {
     }
     const fields = entries.map((entry) => entry.tag);
     const values = entries.map((entry) => entry.value);
-    return new CalcitImpl(implName, fields, values);
+    return new CalcitImpl(implName, fields, values, origin);
 };
 export let _$n_struct_$o__$o_new = (name, ...entries) => {
     return defstruct(name, ...entries);
@@ -451,7 +454,11 @@ export let _$n_tuple_$o_with_impls = function (x, y) {
     if (!(x instanceof CalcitTuple))
         throw new Error("&tuple:with-impls expects a tuple");
     const impl = coerce_impl(y, "&tuple:with-impls");
-    return new CalcitTuple(x.tag, x.extra, [impl], x.enumPrototype);
+    let proto = x.enumPrototype;
+    if (proto == null) {
+        proto = new CalcitEnum(new CalcitRecord(newTag("anonymous-tuple"), [], [], new CalcitStruct(newTag("anonymous-tuple"), [], [])));
+    }
+    return new CalcitTuple(x.tag, x.extra, proto.withImpls(impl));
 };
 export let _$n_tuple_$o_impl_traits = function (x, ...traits) {
     if (traits.length < 1)
@@ -459,7 +466,13 @@ export let _$n_tuple_$o_impl_traits = function (x, ...traits) {
     if (!(x instanceof CalcitTuple))
         throw new Error("&tuple:impl-traits expects a tuple");
     const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
-    return new CalcitTuple(x.tag, x.extra, x.impls.concat(impls), x.enumPrototype);
+    let proto = x.enumPrototype;
+    if (proto == null) {
+        const tagName = x.tag instanceof CalcitTag ? x.tag : newTag("tag");
+        const anyTypes = new CalcitSliceList(new Array(x.extra.length).fill(newTag("any")));
+        proto = new CalcitEnum(new CalcitRecord(newTag("anonymous-tuple"), [tagName], [anyTypes], new CalcitStruct(newTag("anonymous-tuple"), [tagName], [anyTypes])));
+    }
+    return new CalcitTuple(x.tag, x.extra, proto.withImpls(impls));
 };
 export let _$n_tuple_$o_enum = function (x) {
     if (arguments.length !== 1)
@@ -472,7 +485,7 @@ export let _$n_tuple_$o_enum = function (x) {
     if (x.enumPrototype instanceof CalcitEnum) {
         return x.enumPrototype;
     }
-    return new CalcitEnum(x.enumPrototype, null);
+    return new CalcitEnum(x.enumPrototype);
 };
 const unwrap_enum_prototype = (enumPrototype, procName) => {
     if (enumPrototype instanceof CalcitEnum) {
@@ -584,7 +597,7 @@ export let _$n_record_$o_impls = function (xs) {
     if (arguments.length !== 1)
         throw new Error("&record:impls takes 1 argument");
     if (xs instanceof CalcitRecord)
-        return new CalcitSliceList(xs.impls);
+        return new CalcitSliceList(xs.structRef.impls);
     throw new Error("&record:impls expected a record");
 };
 export let _$n_record_$o_impl_traits = function (xs, ...traits) {
@@ -593,7 +606,8 @@ export let _$n_record_$o_impl_traits = function (xs, ...traits) {
     if (!(xs instanceof CalcitRecord))
         throw new Error("&record:impl-traits expected a record");
     const impls = traits.map((trait) => coerce_impl(trait, "&record:impl-traits"));
-    return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(impls));
+    const nextStruct = new CalcitStruct(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(impls));
+    return new CalcitRecord(xs.name, xs.fields, xs.values, nextStruct);
 };
 export let _$n_struct_$o_impl_traits = function (xs, ...traits) {
     if (traits.length < 1)
@@ -609,14 +623,41 @@ export let _$n_enum_$o_impl_traits = function (xs, ...traits) {
         throw new Error("&enum:impl-traits takes 2+ arguments");
     const addedImpls = traits.map((trait) => coerce_impl(trait, "&enum:impl-traits"));
     if (xs instanceof CalcitEnum) {
-        const baseImpls = xs.impls ?? [];
-        return new CalcitEnum(xs.prototype, baseImpls.concat(addedImpls));
+        return xs.withImpls(addedImpls);
     }
     if (xs instanceof CalcitRecord) {
-        return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(addedImpls));
+        const nextStruct = new CalcitStruct(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(addedImpls));
+        return new CalcitRecord(xs.name, xs.fields, xs.values, nextStruct);
     }
     throw new Error("&enum:impl-traits expected an enum or enum record");
 };
+export let _$n_impl_$o_origin = function (impl) {
+    if (arguments.length !== 1)
+        throw new Error("&impl:origin expected 1 argument");
+    if (impl instanceof CalcitImpl) {
+        return impl.origin ?? null;
+    }
+    throw new Error(`&impl:origin expected an impl, but received: ${toString(impl, true)}`);
+};
+export let _$n_impl_$o_get = function (impl, name) {
+    if (arguments.length !== 2)
+        throw new Error("&impl:get expected 2 arguments");
+    if (!(impl instanceof CalcitImpl)) {
+        throw new Error(`&impl:get expected an impl as first argument, but received: ${toString(impl, true)}`);
+    }
+    return impl.get(name);
+};
+export let _$n_impl_$o_nth = function (impl, index) {
+    if (arguments.length !== 2)
+        throw new Error("&impl:nth expected 2 arguments");
+    if (!(impl instanceof CalcitImpl)) {
+        throw new Error(`&impl:nth expected an impl as first argument, but received: ${toString(impl, true)}`);
+    }
+    if (typeof index !== "number" || !Number.isInteger(index) || index < 0) {
+        throw new Error(`&impl:nth expected a non-negative integer index, but received: ${toString(index, true)}`);
+    }
+    return impl.values[index];
+};
 export let _$n_list_$o_assoc_before = function (xs, k, v) {
     if (arguments.length !== 3) {
         throw new Error("assoc takes 3 arguments");
@@ -1485,7 +1526,7 @@ export let _$n_js_object = (...xs) => {
     return ret;
 };
 export let _$o__$o_ = (tagName, ...extra) => {
-    return new CalcitTuple(tagName, extra, [], null);
+    return new CalcitTuple(tagName, extra, null);
 };
 export let _PCT__$o__$o_ = (enumPrototype, tag, ...extra) => {
     const proto = assert_enum_tag_args("%::", enumPrototype, tag);
@@ -1505,7 +1546,7 @@ export let _PCT__$o__$o_ = (enumPrototype, tag, ...extra) => {
         throw new Error(`Expected variant definition to be a list, got ${variantDefinition}`);
     }
     const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
-    return new CalcitTuple(tag, extra, [], tupleEnumPrototype);
+    return new CalcitTuple(tag, extra, tupleEnumPrototype);
 };
 export let _PCT__PCT__$o__$o_ = (impl, enumPrototype, tag, ...extra) => {
     // Runtime validation: check if tag exists in enum and arity matches
@@ -1527,7 +1568,7 @@ export let _PCT__PCT__$o__$o_ = (impl, enumPrototype, tag, ...extra) => {
     }
     const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
     const implValue = coerce_impl(impl, "%:: with impl");
-    return new CalcitTuple(tag, extra, [implValue], tupleEnumPrototype);
+    return new CalcitTuple(tag, extra, tupleEnumPrototype.withImpls(implValue));
 };
 let calcit_builtin_impls = {
     number: null,
@@ -1574,7 +1615,7 @@ function lookup_impls(obj) {
     }
     else if (obj instanceof CalcitRecord) {
         tag = obj.name.toString();
-        impls = obj.impls;
+        impls = obj.structRef.impls;
     }
     else if (obj instanceof CalcitTuple) {
         tag = obj.tag.toString();
@@ -1686,7 +1727,8 @@ export function _$n_inspect_methods(obj, note) {
         for (let k = 0; k < impl.fields.length; k++) {
             names.push("." + impl.fields[k].value);
         }
-        console.log(`  #${i}: ${impl.name.toString()}  (${names.join(" ")})`);
+        const originName = impl.origin != null ? impl.origin.name.toString() : impl.name.toString();
+        console.log(`  #${i}: ${originName}  (${names.join(" ")})`);
     }
     let ms = _$n_methods_of(obj);
     console.log(`\nAll methods (unique, high → low): ${ms.len()}`);
@@ -1716,7 +1758,7 @@ export function _$n_trait_call(traitDef, method, obj, ...args) {
     let idx = reverse ? impls.length - 1 : 0;
     while (reverse ? idx >= 0 : idx < impls.length) {
         const impl = impls[idx];
-        if (impl != null && impl.name.value === traitDef.name.value) {
+        if (impl != null && impl.origin != null && impl.origin.name.value === traitDef.name.value) {
             const fn = impl.getOrNil(methodName);
             if (fn != null) {
                 if (typeof fn !== "function") {
@@ -1864,8 +1906,5 @@ export let gensym = unavailableProc;
 export let macroexpand = unavailableProc;
 export let macroexpand_all = unavailableProc;
 export let _$n_get_calcit_running_mode = unavailableProc;
-export let _args_throw = (name, expected, got) => {
-    return new Error(`\`${name}\` expected ${expected} params, got ${got}`);
-};
 // already handled in code emitter
 export let raise = unavailableProc;