@calcit/procs 0.12.48 → 0.12.50

package/editing-history/2026-07-19-1919-type-introspection-consistency.md

@@ -0,0 +1,24 @@
+# Edit History - Type Introspection Consistency Fixes
+
+- **Objective**: Close gaps found while researching "how to discover a type's fields/methods in Calcit" (methods via traits/impls, fields via records, Display formatting). Documented findings and a prioritized fix plan in `RFCs/07-19-type-introspection-consistency-rfc.md`, then implemented items 1-3 (item 4 deferred as optional/out of scope for this pass).
+
+- **Fix 1 — `Enum` `Display` now includes variants** (`src/calcit.rs`):
+  - Previously `Calcit::Enum` printed only `(%enum :Name)`, discarding the already-tracked `variants()` (tag + payload types). Now prints `(%enum :Name (:variant1 type ...) (:variant2 ...) ...)`, matching the richness of `Struct`'s Display.
+  - Test: `enum_display_includes_variants` in `src/calcit.rs`'s test module.
+
+- **Fix 2 — `&methods-of`/`&inspect-methods` accept bare `Struct`/`Enum`/`Trait` values** (not just instances):
+  - `src/builtins/meta.rs`: `collect_impl_records_for_value` gained `Calcit::Struct`/`Calcit::Enum` arms (read their own `impls` field directly). `iter_impls_in_precedence_order` now treats `Struct`/`Enum` the same as `Tuple`/`Record` (last-attached impl wins, i.e. reversed iteration) since `&struct:impl-traits`/`&enum:impl-traits` also `.extend()` impls onto the end.
+  - `Calcit::Trait` handled as a special case (new helper `trait_dot_method_names`) since traits declare methods directly, not via an `impls` list — no `impls` field exists on `CalcitTrait`.
+  - JS target parity: `ts-src/calcit.procs.mts`'s `lookup_impls` gained `CalcitStruct`/`CalcitEnum` branches; the `reverse`-order flag (previously only `CalcitRecord || CalcitTuple`) now also includes `CalcitStruct || CalcitEnum`; `_$n_methods_of`/`_$n_inspect_methods` special-case `CalcitTrait` the same way as the Rust side.
+  - Test: `calcit/test-traits.cirru`'s `test-method-introspection` — new `let` block calling `&methods-of` on `(impl-traits Person0 MyFooImpl)` (bare struct), `DemoBar` (bare enum), `MyFoo` (bare trait), asserting the expected method tags show up. Edited via `cr tree insert-after` (module entry must be the module's own file, e.g. `cr calcit/test-traits.cirru ...`, NOT the aggregated `calcit/test.cirru` — `cr tree`/`cr edit` couldn't resolve the namespace when invoked through the aggregator, while `cr query` could).
+
+- **Fix 3 — `to-pairs`/`keys` type signature no longer false-warns on records**:
+  - `src/calcit/type_annotation.rs`: `matches_with_bindings`'s `(TypeRef, Record)` arm previously only matched if the `TypeRef` name equaled the record's own struct name (e.g. `"map"` vs `"Person"` → false). Added: when the `TypeRef` name is the generic `"map"` placeholder, match any record structurally (records are field-name → value, i.e. map-like), in addition to the existing exact-name match.
+  - Test: `generic_map_type_ref_accepts_records_structurally` in `src/calcit/type_annotation.rs`'s test module — verifies `TypeRef("map")` matches `Record(Person)` both directions, and confirms unrelated `TypeRef` names still don't match structurally (no over-broadening).
+  - Note: empirically, `cr --check-only` on `test-record.cirru` didn't show a warning for `keys p2` even before this fix (likely because that call site's static type inference doesn't currently narrow `p2` to `Record`), so this is a defensive/forward-looking fix for when static inference improves or explicit type annotations are used, not a fix for an observed regression today.
+
+- **Deferred (RFC item 4, optional)**: `&struct:fields`/`&enum:variants` new introspection procs — would require registering a new `CalcitProc` end-to-end (proc_name.rs signature + string mapping, builtins.rs dispatch, records.rs/meta.rs impl, JS/IR/WASM codegen parity). Judged lower priority/cost-to-benefit than items 1-3 which fixed real capability gaps; left as a follow-up.
+
+- **Tooling note**: `cr tree`/`cr edit` subcommands need the entry file to be the *specific module's own `.cirru` file* (e.g. `calcit/test-traits.cirru`) to resolve `<ns>/<def>` targets — passing the aggregator entry (`calcit/test.cirru`, which just lists the module in `:modules`) causes `Error: "Namespace '...' not found"` for `tree`/`edit` even though `cr query defs/def` works fine through the aggregator. `--file` snippet content must be `quote`-prefixed (e.g. `quote (let (...) ...)`) even though the repo's `Agents.md` `--stdin` removal note doesn't mention this requirement explicitly.
+
+- **Validation**: `cargo fmt`, `cargo clippy -- -D warnings`, `cargo test` (239 lib tests incl. 2 new), `cargo run --bin cr -- calcit/test.cirru`, `yarn check-all` (compile + try-rs + try-js + try-ir + try-wasm) — all clean/passing.

package/editing-history/2026-07-19-1930-schema-tag-roundtrip-fix.md

@@ -0,0 +1,64 @@
+# Schema kind tag round-trip regression fix (2026-07-19 19:30)
+
+## Symptom
+
+Running `cr tree insert-after`/`cr edit` on [calcit/test-traits.cirru](../calcit/test-traits.cirru)
+(to add new `test-method-introspection` assertions) silently rewrote the `:schema`
+field of *every other, unrelated* def in the same file from its specific kind tag
+(`:enum`, `:trait`, `:impl`, `:struct`) down to `:schema :dynamic`. This affected
+~15 defs (`Demo0`, `DemoBar`, `MyBar`, `MyBarImpl`, `MyFoo`, `MyFooImpl`, `Person0`,
+etc.) that were never touched by the edit itself — any save of the file degraded
+their schema fidelity as a side effect.
+
+## Root cause
+
+`:struct`/`:enum`/`:trait`/`:impl`/`:record` shorthand schema tags load into
+`CalcitTypeAnnotation::Custom(Arc<Calcit>)` (see `CalcitTypeAnnotation::from_tag_name`
+in [src/calcit/type_annotation.rs](../src/calcit/type_annotation.rs)), wrapping the
+kind as a bare `Calcit::Tag`. On save, `schema_annotation_to_edn` (in
+[src/snapshot.rs](../src/snapshot.rs)) converted the in-memory schema back to EDN via
+`CalcitTypeAnnotation::builtin_tag_name()`, which only handles primitive scalar
+types (`bool`, `number`, `string`, ...) and has no arm for `Custom`, `Record`,
+`Struct`, `Enum`, or `Trait` — those all fell through the `_ => None` catch-all,
+so `schema_annotation_to_edn` silently defaulted to `Edn::tag("dynamic")`.
+
+Since `code_entry_edn_pairs` recomputes every entry's schema EDN from its in-memory
+`CalcitTypeAnnotation` on *every* file save (not just for touched defs), any
+`cr edit`/`cr tree` write to a file containing these shorthand-tagged schemas
+degrades them all to `:dynamic`, regardless of which def was actually edited.
+
+Note `builtin_tag_name()` is also used by `to_brief_string()` and other call
+sites that intentionally want more specific output (e.g. `struct Person` instead
+of a bare `:struct`) for those variants — so widening `builtin_tag_name()` itself
+to cover them would have regressed those call sites. The fix instead lives
+directly in `schema_annotation_to_edn`, which is the one place that needs the
+short kind-tag representation for the snapshot file format.
+
+## Fix
+
+Added explicit match arms to `schema_annotation_to_edn` in [src/snapshot.rs](../src/snapshot.rs):
+- `Custom(value)`: coerce the wrapped `Calcit::Tag` back into its `Edn::Tag` (falls
+  back to `:dynamic` only if the wrapped value isn't a bare tag, which shouldn't
+  happen via `from_tag_name`).
+- `Record(_)` → `:record`, `Struct(..)` → `:struct`, `Enum(..)` → `:enum`,
+  `Trait(_)` → `:trait`.
+
+This preserves the user's original expressed intent (e.g. `:schema :impl`) instead
+of silently downgrading it to `:dynamic`, which would otherwise turn off
+schema-based type-checking coverage for those defs.
+
+Recovered the previously-corrupted `calcit/test-traits.cirru` by reverting to
+`git checkout` and reapplying the new `test-method-introspection` assertions with
+the fixed binary — confirmed via `git diff` that this time only the intended
+7 new lines changed, with zero incidental `:schema` churn.
+
+## Regression test
+
+`test_custom_kind_schema_tags_round_trip_instead_of_degrading_to_dynamic` in
+[src/snapshot.rs](../src/snapshot.rs) asserts `schema_annotation_to_edn(CalcitTypeAnnotation::from_tag_name(kind))`
+round-trips to `Edn::tag(kind)` for `struct`/`enum`/`trait`/`impl`/`record`.
+
+## Validation
+
+`cargo fmt`, `cargo clippy --all-targets -- -D warnings`, `cargo test` (all pass),
+`yarn check-all` (exit 0).

package/editing-history/20260719-2236-doc-knowledge-graph.md

@@ -0,0 +1,27 @@
+# 2026-07-19 22:36 文档知识图谱与增量缓存
+
+## 修改概要
+
+- 为 `cr docs` 增加文档知识图构建、检查、关系遍历、路径查询、定义反查、缺失定义和孤立节点命令。
+- 使用 Markdown frontmatter 的 `id`、`parent`、`related`、`requires`、`leads_to`、`code_refs` 表达可 Git 管理的知识关系。
+- 在 `~/.config/calcit/docs-cache/` 生成 JSON 文本缓存，按文件内容、解析器/schema 版本和内置 Calcit snapshot 指纹失效。
+- 为文档索引 RFC、`CalcitAgent.md`、索引规范和验证案例补充使用说明。
+- 为核心数据结构文档补充稳定节点 ID 与 Calcit 定义引用，验证从概念到 API 和编辑工作流的跳转。
+
+## 验证
+
+- `cargo fmt --all`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test -q`
+- `yarn compile`
+- `cr docs graph build`
+- `cr docs graph check`
+- `cr docs graph path core/features/list core/run/edit-tree`
+- `cr docs graph explain calcit.core/nth`
+- `cr docs graph missing`
+- `cr docs graph orphans`
+
+## 后续方向
+
+- 将 `missing` 从总量报告扩展为按公共 API、语法符号和内部定义分类。
+- 接入模块或应用级 Calcit snapshot，并增加示例覆盖检查与 LLM context 聚合。

package/editing-history/20260719-2245-doc-graph-missing-filter.md

@@ -0,0 +1,17 @@
+# 2026-07-19 22:45 graph missing 分批筛选
+
+## 修改概要
+
+- 为 `cr docs graph missing` 增加 `--ns` namespace 前缀过滤。
+- 增加 `--limit` 输出数量限制，便于按批次补充公共 API 的 `code_refs`。
+- 在 `CalcitAgent.md` 和知识图谱 RFC 中补充该操作说明。
+- 增加 namespace 过滤、数量限制和内部命名排除的单元测试。
+
+## 验证
+
+- `cargo fmt --all`
+- `cargo test -q`
+- `cargo clippy --all-targets -- -D warnings`
+- `yarn compile`
+- `cr docs graph missing --ns calcit.core --limit 5`
+- `git diff --check`

package/editing-history/20260719-2310-doc-graph-explain-full.md

@@ -0,0 +1,16 @@
+# 2026-07-19 23:10 graph explain 定义摘要
+
+## 修改概要
+
+- 为 `cr docs graph explain` 增加 `--full`，输出 Calcit 定义的 doc 和 examples 可用性。
+- 缓存定义记录保存 doc 文本，并将 cache schema 升级为 5，确保旧缓存自动重建。
+- 更新 command echo、`CalcitAgent.md` 和 graph 验证案例。
+
+## 验证
+
+- `cargo fmt --all`
+- `cargo test -q`
+- `cargo clippy --all-targets -- -D warnings`
+- `yarn compile`
+- `cr docs graph explain calcit.core/nth --full`
+- `git diff --check`

package/lib/calcit-data.mjs

@@ -210,6 +210,14 @@ export let hashFunction = (x) => {
         return h;
     }
     if (typeof x === "function") {
+        // method values are closures created on the fly (see invoke_method_closure);
+        // hash by method name so equal methods share the same hash, matching isEqual
+        const methodName = x.__calcitMethodName;
+        if (methodName != null) {
+            let h = mergeValueHash(defaultHash_fn, methodName);
+            x[calcit_dirty_hash_key] = h;
+            return h;
+        }
         fnHashCounter = fnHashCounter + 1;
         let h = mergeValueHash(defaultHash_fn, fnHashCounter);
         x[calcit_dirty_hash_key] = h;
@@ -383,6 +391,10 @@ export let toString = (x, escaped, disableJsDataWarning = false) => {
         return x.toString();
     }
     if (typeof x === "function") {
+        const methodName = x.__calcitMethodName;
+        if (methodName != null) {
+            return "." + methodName;
+        }
         return `(&fn ...)`;
     }
     if (x instanceof CalcitSymbol) {
@@ -541,7 +553,14 @@ export let _$n__$e_ = (x, y) => {
         return false;
     }
     if (tx === "function") {
-        // comparing functions by reference
+        // method values are closures created on the fly (see invoke_method_closure),
+        // so two methods with the same name must compare equal by name, not by reference
+        const mx = x.__calcitMethodName;
+        const my = y.__calcitMethodName;
+        if (mx != null || my != null) {
+            return mx === my;
+        }
+        // comparing plain functions by reference
         return x === y;
     }
     if (x instanceof CalcitTag) {

package/lib/calcit.procs.mjs

@@ -1834,6 +1834,17 @@ function lookup_impls(obj) {
         tag = "&core-set-methods";
         impls = normalize_builtin_impls(calcit_builtin_impls.set);
     }
+    else if (obj instanceof CalcitStruct) {
+        // Bare type definitions (not yet instantiated) carry their own attached
+        // impls, so introspection tools like `&methods-of` can answer "what
+        // methods will instances of this type have" without a concrete instance.
+        tag = obj.name.toString();
+        impls = obj.impls;
+    }
+    else if (obj instanceof CalcitEnum) {
+        tag = obj.name();
+        impls = obj.impls;
+    }
     else if (typeof obj === "number") {
         tag = "&core-number-methods";
         impls = normalize_builtin_impls(calcit_builtin_impls.number);
@@ -1862,7 +1873,7 @@ export function invoke_method(p, obj, ...args) {
     let tag = pair[1];
     // builtin impl lists are ordered by priority in calcit-core.
     // user-defined values use impl-traits append, so later impls override earlier ones.
-    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
     let idx = reverse ? impls.length - 1 : 0;
     while (reverse ? idx >= 0 : idx < impls.length) {
         let klass = impls[idx];
@@ -1882,12 +1893,16 @@ export function invoke_method(p, obj, ...args) {
 export function _$n_methods_of(obj) {
     if (arguments.length !== 1)
         throw new Error("&methods-of expected 1 argument");
+    // Traits declare methods directly rather than through attached impls.
+    if (obj instanceof CalcitTrait) {
+        return new CalcitSliceList(obj.methods.map((m) => invoke_method_closure(m.value)));
+    }
     let pair = lookup_impls(obj);
     if (pair == null) {
         throw new Error(`&methods-of cannot resolve impls for: ${toString(obj, true)}`);
     }
     let impls = pair[0];
-    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
     let seen = new Set();
     let ys = [];
     let idx = reverse ? impls.length - 1 : 0;
@@ -1895,10 +1910,11 @@ export function _$n_methods_of(obj) {
         let impl = impls[idx];
         if (impl != null) {
             for (let k = 0; k < impl.fields.length; k++) {
-                let name = "." + impl.fields[k].value;
+                let rawName = impl.fields[k].value;
+                let name = "." + rawName;
                 if (!seen.has(name)) {
                     seen.add(name);
-                    ys.push(name);
+                    ys.push(invoke_method_closure(rawName));
                 }
             }
         }
@@ -1909,12 +1925,26 @@ export function _$n_methods_of(obj) {
 export function _$n_inspect_methods(obj, note) {
     if (arguments.length !== 2)
         throw new Error("&inspect-methods expected 2 arguments");
+    if (obj instanceof CalcitTrait) {
+        console.log("\n&inspect-methods");
+        console.log(`Note: ${toString(note, true)}`);
+        console.log(`Value type: ${type_of(obj).toString()}`);
+        console.log(`Value: ${toString(obj, true)}`);
+        console.log("Method call syntax: `.method self p1 p2`");
+        console.log("  - dot is part of the method name, first arg is the receiver\n");
+        const names = obj.methods.map((m) => "." + m.value);
+        console.log(`Trait methods declared directly (no impls): ${names.length}`);
+        console.log(`\nAll methods (unique, high → low): ${names.length}`);
+        console.log("  " + names.join(" "));
+        console.log("\n");
+        return obj;
+    }
     let pair = lookup_impls(obj);
     if (pair == null) {
         throw new Error(`&inspect-methods cannot resolve impls for: ${toString(obj, true)}`);
     }
     let impls = pair[0];
-    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
     console.log("\n&inspect-methods");
     console.log(`Note: ${toString(note, true)}`);
     console.log(`Value type: ${type_of(obj).toString()}`);
@@ -1941,7 +1971,7 @@ export function _$n_inspect_methods(obj, note) {
     }
     let ms = _$n_methods_of(obj);
     console.log(`\nAll methods (unique, high → low): ${ms.len()}`);
-    console.log("  " + Array.from(ms.items()).join(" "));
+    console.log("  " + Array.from(ms.items()).map((m) => toString(m, false)).join(" "));
     console.log("\n");
     return obj;
 }
@@ -1963,7 +1993,7 @@ export function _$n_trait_call(traitDef, method, obj, ...args) {
         throw new Error(`&trait-call cannot resolve impls for: ${toString(obj, true)}`);
     }
     const impls = pair[0];
-    const reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+    const reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
     let idx = reverse ? impls.length - 1 : 0;
     while (reverse ? idx >= 0 : idx < impls.length) {
         const impl = impls[idx];

package/lib/package.json

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

package/package.json

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

package/ts-src/calcit-data.mts

@@ -238,6 +238,14 @@ export let hashFunction = (x: CalcitValue): Hash => {
     return h;
   }
   if (typeof x === "function") {
+    // method values are closures created on the fly (see invoke_method_closure);
+    // hash by method name so equal methods share the same hash, matching isEqual
+    const methodName = (x as { __calcitMethodName?: string }).__calcitMethodName;
+    if (methodName != null) {
+      let h = mergeValueHash(defaultHash_fn, methodName);
+      (x as any)[calcit_dirty_hash_key] = h;
+      return h;
+    }
     fnHashCounter = fnHashCounter + 1;
     let h = mergeValueHash(defaultHash_fn, fnHashCounter);
     (x as any)[calcit_dirty_hash_key] = h;
@@ -412,6 +420,10 @@ export let toString = (x: CalcitValue, escaped: boolean, disableJsDataWarning: b
     return x.toString();
   }
   if (typeof x === "function") {
+    const methodName = (x as { __calcitMethodName?: string }).__calcitMethodName;
+    if (methodName != null) {
+      return "." + methodName;
+    }
     return `(&fn ...)`;
   }
   if (x instanceof CalcitSymbol) {
@@ -579,7 +591,14 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
     return false;
   }
   if (tx === "function") {
-    // comparing functions by reference
+    // method values are closures created on the fly (see invoke_method_closure),
+    // so two methods with the same name must compare equal by name, not by reference
+    const mx = (x as { __calcitMethodName?: string }).__calcitMethodName;
+    const my = (y as { __calcitMethodName?: string }).__calcitMethodName;
+    if (mx != null || my != null) {
+      return mx === my;
+    }
+    // comparing plain functions by reference
     return x === y;
   }
   if (x instanceof CalcitTag) {

package/ts-src/calcit.procs.mts

@@ -1946,6 +1946,15 @@ function lookup_impls(obj: CalcitValue): [CalcitImpl[], string] {
   } else if (obj instanceof CalcitSet) {
     tag = "&core-set-methods";
     impls = normalize_builtin_impls(calcit_builtin_impls.set);
+  } else if (obj instanceof CalcitStruct) {
+    // Bare type definitions (not yet instantiated) carry their own attached
+    // impls, so introspection tools like `&methods-of` can answer "what
+    // methods will instances of this type have" without a concrete instance.
+    tag = obj.name.toString();
+    impls = obj.impls;
+  } else if (obj instanceof CalcitEnum) {
+    tag = obj.name();
+    impls = obj.impls;
   } else if (typeof obj === "number") {
     tag = "&core-number-methods";
     impls = normalize_builtin_impls(calcit_builtin_impls.number);
@@ -1971,7 +1980,7 @@ export function invoke_method(p: string, obj: CalcitValue, ...args: CalcitValue[
   let tag = pair[1];
   // builtin impl lists are ordered by priority in calcit-core.
   // user-defined values use impl-traits append, so later impls override earlier ones.
-  let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+  let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
   let idx = reverse ? impls.length - 1 : 0;
   while (reverse ? idx >= 0 : idx < impls.length) {
     let klass = impls[idx];
@@ -1991,12 +2000,16 @@ export function invoke_method(p: string, obj: CalcitValue, ...args: CalcitValue[
 
 export function _$n_methods_of(obj: CalcitValue): CalcitSliceList {
   if (arguments.length !== 1) throw new Error("&methods-of expected 1 argument");
+  // Traits declare methods directly rather than through attached impls.
+  if (obj instanceof CalcitTrait) {
+    return new CalcitSliceList(obj.methods.map((m) => invoke_method_closure(m.value)));
+  }
   let pair = lookup_impls(obj);
   if (pair == null) {
     throw new Error(`&methods-of cannot resolve impls for: ${toString(obj, true)}`);
   }
   let impls = pair[0];
-  let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+  let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
   let seen = new Set<string>();
   let ys: CalcitValue[] = [];
 
@@ -2005,10 +2018,11 @@ export function _$n_methods_of(obj: CalcitValue): CalcitSliceList {
     let impl = impls[idx];
     if (impl != null) {
       for (let k = 0; k < impl.fields.length; k++) {
-        let name = "." + impl.fields[k].value;
+        let rawName = impl.fields[k].value;
+        let name = "." + rawName;
         if (!seen.has(name)) {
           seen.add(name);
-          ys.push(name);
+          ys.push(invoke_method_closure(rawName));
         }
       }
     }
@@ -2019,12 +2033,26 @@ export function _$n_methods_of(obj: CalcitValue): CalcitSliceList {
 
 export function _$n_inspect_methods(obj: CalcitValue, note: CalcitValue): CalcitValue {
   if (arguments.length !== 2) throw new Error("&inspect-methods expected 2 arguments");
+  if (obj instanceof CalcitTrait) {
+    console.log("\n&inspect-methods");
+    console.log(`Note: ${toString(note, true)}`);
+    console.log(`Value type: ${type_of(obj).toString()}`);
+    console.log(`Value: ${toString(obj, true)}`);
+    console.log("Method call syntax: `.method self p1 p2`");
+    console.log("  - dot is part of the method name, first arg is the receiver\n");
+    const names = obj.methods.map((m) => "." + m.value);
+    console.log(`Trait methods declared directly (no impls): ${names.length}`);
+    console.log(`\nAll methods (unique, high → low): ${names.length}`);
+    console.log("  " + names.join(" "));
+    console.log("\n");
+    return obj;
+  }
   let pair = lookup_impls(obj);
   if (pair == null) {
     throw new Error(`&inspect-methods cannot resolve impls for: ${toString(obj, true)}`);
   }
   let impls = pair[0];
-  let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+  let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
 
   console.log("\n&inspect-methods");
   console.log(`Note: ${toString(note, true)}`);
@@ -2054,7 +2082,7 @@ export function _$n_inspect_methods(obj: CalcitValue, note: CalcitValue): Calcit
 
   let ms = _$n_methods_of(obj);
   console.log(`\nAll methods (unique, high → low): ${ms.len()}`);
-  console.log("  " + (Array.from(ms.items()) as string[]).join(" "));
+  console.log("  " + Array.from(ms.items()).map((m) => toString(m, false)).join(" "));
   console.log("\n");
 
   return obj;
@@ -2078,7 +2106,7 @@ export function _$n_trait_call(traitDef: CalcitValue, method: CalcitValue, obj:
     throw new Error(`&trait-call cannot resolve impls for: ${toString(obj, true)}`);
   }
   const impls = pair[0];
-  const reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple;
+  const reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
   let idx = reverse ? impls.length - 1 : 0;
   while (reverse ? idx >= 0 : idx < impls.length) {
     const impl = impls[idx];