@calcit/procs 0.12.56 → 0.12.58

package/build.rs

@@ -107,6 +107,41 @@ pub struct Snapshot {
   pub files: HashMap<String, FileInSnapShot>,
 }
 
+fn parse_snapshot_entry(data: Edn) -> Result<SnapshotEntry, String> {
+  let map = data.view_map().map_err(|e| format!("entry must be a map: {e}"))?;
+  let ns_def = |key: &str| match map.get_or_nil(key) {
+    Edn::Str(text) | Edn::Symbol(text) => Ok(text.to_string()),
+    other => Err(format!(
+      "entry `:{key}` must be a namespace/definition string or symbol, got {other:?}"
+    )),
+  };
+  let mode = match map.get_or_nil("mode") {
+    Edn::Tag(tag) if tag.ref_str() == "native" => SnapshotRunMode::Native,
+    Edn::Tag(tag) if tag.ref_str() == "js" => SnapshotRunMode::Js,
+    Edn::Str(text) | Edn::Symbol(text) if text.trim_start_matches(':') == "native" => SnapshotRunMode::Native,
+    Edn::Str(text) | Edn::Symbol(text) if text.trim_start_matches(':') == "js" => SnapshotRunMode::Js,
+    other => return Err(format!("entry `:mode` must be :native or :js, got {other:?}")),
+  };
+  Ok(SnapshotEntry {
+    mode,
+    init_fn: ns_def("init-fn")?,
+    reload_fn: ns_def("reload-fn")?,
+    description: from_edn(map.get_or_nil("description")).map_err(|e| format!("entry `:description`: {e}"))?,
+    modules: from_edn(map.get_or_nil("modules")).map_err(|e| format!("entry `:modules`: {e}"))?,
+    type_slots: from_edn(map.get_or_nil("type-slots")).map_err(|e| format!("entry `:type-slots`: {e}"))?,
+  })
+}
+
+fn parse_entries(data: Edn) -> Result<HashMap<String, SnapshotEntry>, String> {
+  let map = data.view_map().map_err(|e| format!("entries must be a map: {e}"))?;
+  let mut entries = HashMap::with_capacity(map.0.len());
+  for (name, value) in map.0 {
+    let name: String = from_edn(name).map_err(|e| format!("invalid entry name: {e}"))?;
+    entries.insert(name, parse_snapshot_entry(value)?);
+  }
+  Ok(entries)
+}
+
 fn format_edn_preview(value: &Edn) -> String {
   let raw = cirru_edn::format(value, true).unwrap_or_else(|_| format!("{value:?}"));
   const LIMIT: usize = 220;
@@ -479,8 +514,7 @@ fn main() {
       Some(from_edn::<LegacySnapshotConfigs>(value).unwrap_or_else(|e| panic!("failed to parse calcit-core legacy `:configs`: {e}")))
     }
   };
-  let mut entries: HashMap<String, SnapshotEntry> =
-    from_edn(data.get_or_nil("entries")).unwrap_or_else(|e| panic!("failed to parse calcit-core `:entries`: {e}"));
+  let mut entries = parse_entries(data.get_or_nil("entries")).unwrap_or_else(|e| panic!("failed to parse calcit-core `:entries`: {e}"));
   if let Some(configs) = &legacy_configs {
     entries.insert(
       "default".to_owned(),

package/editing-history/202608011759-issue-routing-in-agent-guide.md

@@ -0,0 +1,17 @@
+# Route discovered issues to their owning repository
+
+## Summary
+
+- Add an Agent-guide rule requiring reproducible Calcit language, runtime, compiler, and CLI issues to be filed with their maintenance repository.
+- Route module and library defects from their resolved local path to the library's own GitHub repository, rather than reporting them to the consuming project or Calcit core by default.
+- Document explicit cross-repository issue creation with `gh issue create --repo OWNER/REPO`, target verification with `gh repo view`, evidence requirements, and safe handling of sensitive reproduction data.
+
+## Validation
+
+- Confirmed `gh issue create --help` exposes `--repo [HOST/]OWNER/REPO` for selecting another repository.
+- Confirmed the current GitHub CLI authentication can query the non-current `calcit-lang/setup-cr` repository.
+- `cargo build --bin cr`
+- `cargo test --bin cr agents_docs_default_to_the_version_matched_embedded_guide`
+- `./target/debug/cr docs check-md docs/CalcitAgent.md --entry calcit/test.cirru --failures-only`
+- `./target/debug/cr docs graph check`
+- `git diff --check`

package/editing-history/202608011833-schema-type-symbols.md

@@ -0,0 +1,20 @@
+# Canonical schema types use quoted symbols
+
+## Summary
+
+- Keep legacy lowercase type tags load-compatible, while making quoted symbols such as `'String`, `'List`, `'Fn`, and `'Dynamic` the canonical schema serialization.
+- Make `cr edit format` rewrite only recognized type positions in schemas, hints, assertions, coercions, structs, and enums; ordinary tag data remains unchanged.
+- Migrate repository Snapshots, type-query/IR/agent-interface output, build-time core Snapshot loading, and primary type documentation.
+
+## Validation
+
+- `cargo fmt`
+- `cargo test`
+- `cargo clippy -- -D warnings`
+- `yarn compile`
+- `yarn check-all`
+- `yarn check-agent-interface`
+- `cr docs check-md docs/features/static-analysis.md --entry calcit/test.cirru --failures-only`
+- `cr docs check-md docs/CalcitAgent.md --entry calcit/test.cirru --failures-only`
+- `cr docs graph check`
+- formatted every valid repository Snapshot with `cr edit format`, then `cr calcit/test.cirru --check-only`

package/editing-history/202608011852-wasm-dynamic-string-tag.md

@@ -0,0 +1,7 @@
+# WASM dynamic string tag
+
+- Schema type migration removed legacy type tags from program data, which can shift WASM's program-local tag indices.
+- The Node.js WASM test host must not assume that the `string` type tag always has index 34.
+- Export the generated module's actual string tag as `__string_tag` and use that value when the host validates or allocates strings.
+- Keep the test host compatible with older generated modules by recovering the tag from their static string pool when the export is absent.
+- Regression command: `cargo build --bin cr-wasm && CR_WASM_BIN=./target/debug/cr-wasm bash scripts/test-wasm.sh`.

package/editing-history/202608011908-consolidate-history.md

@@ -0,0 +1,6 @@
+# Consolidate historical editing notes
+
+- Replaced 142 individual notes from June 2026 and earlier with a compact topic index.
+- Retained all July–August notes for active maintenance context.
+- The removed notes remain recoverable through Git history; `editing-history/README.md` documents the retention rule.
+- Verification: reviewed the tracked path set and checked the resulting Git diff.

package/editing-history/202608012022-consolidate-cli-and-test-duplication.md

@@ -0,0 +1,28 @@
+# Consolidate CLI and test duplication
+
+## Summary
+
+- Introduced a typed `TreeOperation` model and shared cursor path transforms so edit, tree, and cursor commands use one implementation for structural mutations.
+- Reused one staged-file abstraction for atomic cursor writes and edit transactions, including permission preservation, sync, commit, and cleanup behavior.
+- Consolidated query result collection/rendering and type-coverage scope traversal without changing their JSON envelopes or diagnostics.
+- Added one test-only temporary project fixture shared by edit, cursor, and query tests.
+- Replaced eight identical Calcit test-local `log-title` definitions with `util.core/log-title`, keeping each standalone snapshot loadable through its module configuration.
+- Removed the misspelled `test-gynienic.cirru` snapshot because the typed `test-hygienic.cirru` suite is a strict superset, and removed the identical `test-cond` runtime case from the macro suite.
+- Made the remaining `case-default` macroexpansion assertion deterministic by resetting the gensym counter before checking the generated symbol.
+
+## Review notes
+
+- Kept repeated `main!` and `reload!` definitions because they are snapshot entry points rather than interchangeable helpers.
+- Kept similarly named macro, native, JS, and WASM tests when they exercise different expansion or backend behavior.
+- The resulting tracked diff removes more code than it adds while retaining the command boundaries and test coverage.
+
+## Validation
+
+- `cargo fmt`
+- `cargo clippy -- -D warnings`
+- `cargo test`
+- `yarn compile`
+- `yarn check-agent-interface` (12/12 scenarios)
+- `yarn check-all` (native, JS, and WASM)
+- Standalone native runs for the updated Calcit snapshots, including `test-cond.cirru`, `test-macro.cirru`, and `test-hygienic.cirru`
+- Real-project Respo regression with JSON definition query and summary-only type-coverage analysis

package/editing-history/202608012123-review-follow-up.md

@@ -0,0 +1,18 @@
+# Review follow-up for CLI consolidation
+
+## Summary
+
+- Updated staged-file rewriting to open the temporary file with write access, truncate it, write through the same handle, and then sync it. This keeps `sync_all` valid on Windows.
+- Reject symbolic-link destinations before staging so an atomic rename cannot silently replace the link while preserving permissions from its target.
+- Avoid copying every definition tree during whole-project search; only a subtree selected by `--start-path` remains owned.
+- Corrected cursor feedback so replace, swap, unwrap, and wrap report an unaffected cursor when their path did not change.
+
+## Tests
+
+- Added staged write/commit coverage and a Unix symbolic-link rejection test.
+- Added cursor feedback assertions for unrelated paths and single-child unwraps.
+
+## Review disposition
+
+- Kept the existing parent-context preview for `query search-expr`; it predates this refactor and is intentional shared search presentation rather than a regression.
+- Deferred directory `fsync` after rename: it is a larger crash-durability policy decision, especially for multi-file commits, and is not needed to correct the current atomic rename behavior.

package/editing-history/202608012320-release-0.12.57.md

@@ -0,0 +1,5 @@
+# Release 0.12.57
+
+- Release the merged CLI mutation, atomic staging, and test deduplication work from PR #284.
+- Include the follow-up fixes for Windows staged-file synchronization, symlink destinations, query cloning, and cursor feedback.
+- Synchronize the Rust crate and npm package versions, then refresh the workspace lockfile before publishing.

package/editing-history/202608012344-release-main-policy.md

@@ -0,0 +1,5 @@
+# Release main-branch policy
+
+- Main no longer requires pull-request protection for verified changes.
+- The release flow now requires the stable version commit to be on `main`, followed by a fresh main-branch CI run before tagging and creating the release.
+- Corrected the npm verification command to use the published package name, `@calcit/procs`.

package/editing-history/202608020058-data-api-and-trait-coverage.md

@@ -0,0 +1,26 @@
+# Data API and trait coverage
+
+## Review outcome
+
+- Corrected the core `Option` and `Result` declarations to carry their real generic parameters instead of dynamic payloads.
+- Added the missing high-frequency predicate, fallback, chaining, and error-mapping helpers, with schemas, method bags, docs, and queryable examples.
+- Added the documented-but-missing `Compare` trait for Number and String.
+- Connected the existing `Countable` and `Contains` traits to List, Map, Set, String, Record, and Tuple/enum values for method dispatch, static `:where` checks, and runtime `assert-traits`.
+
+## Cross-platform consistency
+
+- Made Number and String `.compare` visible through the shared built-in method bags so native, JavaScript, and WASM preprocessing agree.
+- Aligned Rust and JavaScript trait introspection for Record/Struct and Tuple/Enum by merging their built-in and attached impl records.
+- Added native, JavaScript, and WASM regression coverage for the new APIs and trait capabilities.
+
+## Type-system fix
+
+- Named generic enum values now safely satisfy builtin dynamic-tuple parameters, while a dynamic tuple still cannot satisfy a concrete named enum.
+- Type-definition resolution now unwraps `def` and `impl-traits` and resolves unqualified core enum references.
+- Tracked the underlying generic-enum diagnostic defect in <https://github.com/calcit-lang/calcit/issues/287>.
+
+## Documentation
+
+- Expanded the data-type overview to distinguish persistent values, named data, executable values, and explicitly stateful containers.
+- Documented Cirru EDN versus JSON fidelity, unsupported values, and restoring declared Record/Enum identity during parsing.
+- Added the built-in trait matrix and the Option/Result helper surface to the polymorphism guide.

package/editing-history/ARCHIVE.md

@@ -0,0 +1,15 @@
+# Consolidated history through June 2026
+
+Detailed task notes before July 2026 were consolidated on 2026-08-01. Their
+full text remains recoverable from Git history; this file preserves the useful
+navigation layer.
+
+| Period | Durable themes |
+| --- | --- |
+| 2025–Feb 2026 | WASM/codegen groundwork, structural equality, diagnostics, core API documentation, and migration toward `defstruct`. |
+| Mar 2026 | Schema and type-annotation redesign: `hint-fn` migration, schema normalization/validation, generic type references, arity checks, and type-fail coverage. |
+| Apr 2026 | Records/enums, type narrowing and generic dispatch; the WASM runtime gained collections, strings, methods, host imports, and multi-module tests. |
+| May–Jun 2026 | Weak-type analysis, data-definition bounds, markdown checking, compiled-runtime backfill, scoped type slots, effects graph, and Agent/CLI documentation. |
+
+For current behavior, prefer `docs/`, tests, and the retained July–August notes
+over this summary.

package/editing-history/README.md

@@ -0,0 +1,21 @@
+# Editing history
+
+This directory keeps short, task-specific notes that help with nearby follow-up
+work. It is not a second changelog: exact prior notes remain available from Git
+history after they leave this directory.
+
+## Retention
+
+- Keep individual notes for the current development window (normally the most
+  recent 45 days).
+- Periodically replace older clusters with a concise topic summary in
+  [ARCHIVE.md](ARCHIVE.md), then remove their individual files.
+- Each code commit still adds one timestamped note, but it should capture only
+  durable context: the reason for the change, compatibility constraints, and
+  the relevant verification command.
+
+To recover a removed note, search the repository history, for example:
+
+```bash
+git log --all -- editing-history/
+```

package/history/202608021153-runtime-traits.md

@@ -0,0 +1,23 @@
+# Runtime traits: nominal implementations
+
+## What changed
+
+- Runtime `CalcitTrait` values now have nominal identity, so independently evaluated traits with the same displayed name and method shape do not match accidentally.
+- Concrete `defimpl` values carry their exact trait origin, require the complete declared method set, and reject non-callable methods. Native preprocessing additionally verifies signatures when metadata is available.
+- Tag-based `defimpl` remains compatible as an originless inherent method bag. It continues to support ordinary `.method` dispatch, but cannot satisfy trait bounds, `assert-traits`, or `&trait-call`.
+- Core builtin capability implementations now preserve trait origins in native and JS runtimes, including scalar values. WASM remains an internal validation backend and reports an explicit unsupported-runtime-trait error when preprocessing cannot eliminate trait operations.
+- `cr edit format` emits a non-blocking migration advisory for legacy tag-based trait arguments.
+
+## Verification
+
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `cargo test` (298 library tests, 176 CLI tests)
+- `yarn compile`
+- `yarn check-all` (Agent interface, native, JS, IR, and WASM)
+- `cr docs check-md` for traits, polymorphism, and upgrade documentation; all 24 Cirru blocks round-trip through the current formatter.
+- External Respo check-only, type summary, and targeted example regression.
+
+## Compatibility
+
+This intentionally tightens concrete trait implementation validation. Existing tag-based method bags keep running, with a migration advisory. Code that treated unrelated same-named or partial implementations as satisfying a trait must migrate to a real `deftrait` plus complete nominal `defimpl`.

package/history/202608021227-format-markdown-cirru.md

@@ -0,0 +1,18 @@
+# Markdown Cirru formatter
+
+## What changed
+
+- Added `cr docs format-md <file>` to canonicalize fenced `cirru`, `cirru.no-run`, `cirru.no-check`, and `cirru.cli` blocks in Markdown.
+- Added `--check` for CI: it reports non-canonical blocks without writing the Markdown file.
+- Formatting preserves non-Cirru Markdown and fence labels, parses code directly as multiple Cirru AST roots, and writes using the existing atomic replacement helper.
+- Added CLI help, command-echo support, unit coverage for formatting, parse errors, idempotence, and the non-writing check mode.
+- Documented usage in CLI options and library quality guidance.
+
+## Verification
+
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `cargo test`
+- `yarn compile`
+- `yarn check-all`
+- `cr docs format-md --check` and `cr docs check-md` on affected documentation.

package/history/202608021239-review-trait-followups.md

@@ -0,0 +1,19 @@
+# Trait review follow-ups
+
+## What changed
+
+- Corrected the public `Mappable` capability table: Result joins List, Map, Set, and Option.
+- Documented why `calcit.internal` is excluded from the legacy inherent-impl advisory: bootstrap method bags precede public nominal trait availability.
+- Made builtin literal method introspection tolerant of unavailable core impl lists, matching record and tuple behavior in embedding/unit-test startup states.
+- Corrected `&str:contains?` documentation and schema to describe numeric character-index bounds checking; substring membership remains `&str:includes?`.
+- Restrict primitive trait-name bootstrap fallback to the period before its real core impl list is evaluated, and added a test that reads the embedded core Snapshot to detect table drift.
+
+## Verification
+
+- `cr src/cirru/calcit-core.cirru edit format`
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `cargo test` (300 library tests, 179 CLI tests)
+- `yarn compile`
+- `yarn check-all` (Agent interface, native, JS, IR, WASM)
+- `cr docs check-md --entry calcit/test.cirru docs/features/polymorphism.md`

package/history/202608021251-defimpl-symbol-traits.md

@@ -0,0 +1,8 @@
+# `defimpl` trait arguments use raw symbols
+
+- Migrated ordinary test fixtures from tag-based `defimpl` trait arguments to named `deftrait` values referenced directly as symbols.
+- Kept the new trait definitions' entry schemas as `'Trait`, so the snapshot metadata matches their runtime role.
+- Updated the `defimpl` macro documentation and diagnostics: raw symbols are the standard syntax; tag arguments remain only as legacy inherent-method-bag compatibility.
+- Updated the tuple test to assert the new nominal trait origin rather than the old tag representation.
+
+`&impl::new :name` bootstrap method bags are intentionally unchanged: unlike the macro form, a raw symbol there would be evaluated rather than captured as syntax.

package/history/202608021255-doc-type-symbols.md

@@ -0,0 +1,6 @@
+# Documentation type syntax audit
+
+- Updated the trait guide and quick reference so schema and data-declaration type positions use quoted symbols (`'String`, `'Number`, `'Fn`, and so on).
+- Kept ordinary tag data unchanged, including enum variants, record keys, and schema-map keys such as `:return`.
+- Ran `docs format-md` and `docs check-md` with `calcit/test.cirru` for both updated guides.
+- The wider audit still finds legacy type-tag examples in feature, run, and migration pages. Upgrade/compatibility explanations deliberately retain old spellings; the remaining tutorial/reference pages should be migrated in a dedicated documentation sweep with code-block validation.

package/history/202608021322-postfix-enum-methods.md

@@ -0,0 +1,12 @@
+# Receiver-first enum method calls
+
+- Extended preprocess-time postfix method rewriting to recognize nominal enum
+  receivers as well as records and traits.
+- During core bootstrapping, infer the declared result type of `%some`, `%none`,
+  `%ok`, and `%err` from their schemas, so their values keep enough type
+  information for receiver-first calls such as `res-ok .unwrap-or 9`.
+- Updated Option/Result trait tests and polymorphism documentation to use the
+  receiver-first form, and verified the JavaScript backend emits normal method
+  invocation code.
+- Updated a formatting-advisory fixture assertion whose legacy inherent-impl
+  warning was intentionally removed by the earlier symbol-type migration.

package/history/202608021327-postfix-unwrap-examples.md

@@ -0,0 +1,10 @@
+# Receiver-first unwrap examples
+
+- Migrated the built-in `option:unwrap-or` and `result:unwrap-or` API examples
+  to the typed receiver-first method form.
+- Verified the examples through `analyze check-examples`, the Markdown snippet
+  through `docs check-md`, and generated JavaScript by executing the trait test
+  bundle with Node.js.
+- Kept the two WASM fixtures in function form: the internal WASM backend does
+  not yet lower enum constructor receiver-method calls, while its complete
+  verification suite continues to pass with the supported form.

package/history/202608021507-receiver-first-static-inference.md

@@ -0,0 +1,21 @@
+# Receiver-first calls with stronger static inference
+
+- Extended receiver-first rewriting from Result/Option to every receiver whose
+  static method table is known, including built-in collections, primitives,
+  traits, structs, records, and enums. Prefix calls remain compatible.
+- Preserved concrete `deftrait`, `defimpl`, `defstruct`, and `defenum` metadata
+  through local bindings and imported definitions, so `impl-traits` no longer
+  collapses nominal values to `Dynamic` or a broad `Custom` type.
+- Propagated generic `:where` capabilities into function bodies and enum
+  `match` payloads, including lexical data definitions and nested named type
+  references. `%::` now retains enum identity even when a payload-free variant
+  cannot determine every generic argument.
+- Inferred typed trait-method returns, required struct fields read through
+  `get`, and body-hinted parameter types. Broad `assert-type` checks no longer
+  erase a more precise compatible inferred type.
+- Migrated representative Calcit snapshots and Markdown examples to
+  receiver-first syntax, formatted every touched Cirru block, and executed the
+  documented outputs on native and JavaScript targets.
+- Kept conservative `Dynamic` fallback for opaque FFI values, heterogeneous or
+  genuinely unresolved nested data, and metadata that cannot be resolved
+  without executing arbitrary user code.

package/history/202608021550-review-type-correctness.md

@@ -0,0 +1,6 @@
+# Review type-correctness follow-ups
+
+- Kept named enum compatibility directional: a resolved enum `TypeRef` may satisfy a dynamic tuple parameter, but a dynamic tuple may not satisfy the named enum.
+- Added namespace-qualified source identity to pre-runtime trait references so bootstrap fallback cannot confuse a user trait with a same-named core trait.
+- Let unresolved core Option/Result constructors fall through to schema inference and taught method return inference to read impl methods from resolved enum `TypeRef` values.
+- Added regressions for nominal trait fallback, source trait identity, and chained receiver-first Option/Result calls.

package/history/202608021730-release-0.12.58.md

@@ -0,0 +1,5 @@
+# Release 0.12.58
+
+- Release the receiver-first method inference and trait nominal-identity fixes merged in PR #288.
+- Synchronize the crate, npm package, and Cargo lockfile versions at `0.12.58`.
+- The merge commit passed the main Test and CodeQL workflows before this release commit.

package/lib/calcit.procs.d.mts

@@ -266,6 +266,7 @@ declare let calcit_builtin_impls: {
     fn: CalcitImplEntry;
     tuple: CalcitImplEntry;
     record: CalcitImplEntry;
+    scalar: CalcitImplEntry;
 };
 export declare let register_calcit_builtin_impls: (options: typeof calcit_builtin_impls) => void;
 /** method used as closure */

package/lib/calcit.procs.mjs

@@ -176,47 +176,27 @@ export let _$n_assert_traits = function (value, traitDef) {
     if (!(traitDef instanceof CalcitTrait)) {
         throw new Error(`&assert-traits expected a trait definition, but received: ${toString(traitDef, true)}`);
     }
-    // For records/tuples, only check instance impls (not builtin fallbacks),
-    // matching the Rust runtime behavior of collect_impl_records_for_value.
-    let impls;
-    if (value instanceof CalcitRecord) {
-        impls = value.structRef.impls ?? [];
-    }
-    else if (value instanceof CalcitTuple) {
-        impls = value.impls ?? [];
-    }
-    else {
-        const pair = lookup_impls(value);
-        if (pair == null) {
-            throw new Error(`&assert-traits cannot resolve impls for: ${toString(value, true)}`);
-        }
-        impls = pair[0];
-    }
-    const missing = [];
-    for (let i = 0; i < traitDef.methods.length; i++) {
-        const method = traitDef.methods[i];
-        let exists = false;
-        for (let j = 0; j < impls.length; j++) {
-            const impl = impls[j];
-            if (impl != null && impl.getOrNil(method) != null) {
-                exists = true;
-                break;
-            }
-        }
-        if (!exists)
-            missing.push(method.toString());
+    // Use the same merged builtin + attached impl list as method dispatch.
+    // Otherwise records and tuples can call a builtin method while
+    // `assert-traits` incorrectly claims that the corresponding trait is absent.
+    const pair = lookup_impls(value);
+    if (pair == null) {
+        throw new Error(`&assert-traits cannot resolve impls for: ${toString(value, true)}`);
     }
+    const impls = pair[0];
+    const reverse = value instanceof CalcitRecord || value instanceof CalcitTuple || value instanceof CalcitStruct || value instanceof CalcitEnum;
+    const ordered = reverse ? [...impls].reverse() : impls;
+    const selected = ordered.find((impl) => impl != null && impl.origin === traitDef);
+    if (selected == null) {
+        const available = impls
+            .filter((impl) => impl?.origin != null)
+            .map((impl) => impl.origin.name.toString())
+            .join(" ");
+        throw new Error(`assert-traits failed: ${toString(value, true)} does not nominally implement ${traitDef.toString()}. Available trait impls: ${available || "(none)"}`);
+    }
+    const missing = traitDef.methods.filter((method) => selected.getOrNil(method) == null);
     if (missing.length > 0) {
-        const available = [];
-        for (let j = 0; j < impls.length; j++) {
-            const impl = impls[j];
-            if (impl == null)
-                continue;
-            for (let k = 0; k < impl.fields.length; k++) {
-                available.push(impl.fields[k].toString());
-            }
-        }
-        throw new Error(`assert-traits failed: ${toString(value, true)} does not implement ${traitDef.toString()}. Missing: ${missing.join(" ")}. Available: ${available.join(" ")}`);
+        throw new Error(`assert-traits failed: impl ${selected.name.toString()} for trait ${traitDef.name.toString()} is incomplete. Missing: ${missing.join(" ")}`);
     }
     return value;
 };
@@ -272,12 +252,14 @@ export let _$n_impl_$o__$o_new = (name, ...pairs) => {
         throw new Error("&impl::new expected arguments");
     const origin = name instanceof CalcitTrait ? name : null;
     const implName = origin ? origin.name : castTag(name);
-    if (pairs.length === 0) {
-        return new CalcitImpl(implName, [], [], origin);
-    }
     const entries = [];
-    for (let idx = 0; idx < pairs.length; idx++) {
-        const pairValue = pairs[idx];
+    let sourcePairs = pairs;
+    if (pairs.length === 1 && pairs[0] instanceof CalcitImpl) {
+        const sourceImpl = pairs[0];
+        sourcePairs = sourceImpl.fields.map((field, idx) => new CalcitTuple(field, [sourceImpl.values[idx]], null));
+    }
+    for (let idx = 0; idx < sourcePairs.length; idx++) {
+        const pairValue = sourcePairs[idx];
         let fieldTag;
         let value;
         if (pairValue instanceof CalcitTuple) {
@@ -305,6 +287,23 @@ export let _$n_impl_$o__$o_new = (name, ...pairs) => {
     }
     const fields = entries.map((entry) => entry.tag);
     const values = entries.map((entry) => entry.value);
+    if (origin != null) {
+        const missing = origin.methods.filter((method) => !fields.some((field) => field.value === method.value));
+        const unexpected = fields.filter((field) => !origin.methods.some((method) => method.value === field.value));
+        if (missing.length > 0 || unexpected.length > 0) {
+            const details = [];
+            if (missing.length > 0)
+                details.push(`missing methods: ${missing.join(" ")}`);
+            if (unexpected.length > 0)
+                details.push(`methods not declared by the trait: ${unexpected.join(" ")}`);
+            throw new Error(`&impl::new does not conform to trait ${origin.name.toString()}: ${details.join("; ")}`);
+        }
+        for (const entry of entries) {
+            if (typeof entry.value !== "function") {
+                throw new Error(`&impl::new expects trait method .${entry.tag.value} to be a function, but received: ${toString(entry.value, true)}`);
+            }
+        }
+    }
     return new CalcitImpl(implName, fields, values, origin);
 };
 export let _$n_struct_$o__$o_new = (name, ...entries) => {
@@ -1764,6 +1763,7 @@ let calcit_builtin_impls = {
     fn: null,
     tuple: null,
     record: null,
+    scalar: null,
 };
 // need to register code from outside
 export let register_calcit_builtin_impls = (options) => {
@@ -1839,11 +1839,13 @@ function lookup_impls(obj) {
         // 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;
+        const builtinRecordImpls = normalize_builtin_impls(calcit_builtin_impls.record) ?? [];
+        impls = [...builtinRecordImpls, ...(obj.impls ?? [])];
     }
     else if (obj instanceof CalcitEnum) {
         tag = obj.name();
-        impls = obj.impls;
+        const builtinTupleImpls = normalize_builtin_impls(calcit_builtin_impls.tuple) ?? [];
+        impls = [...builtinTupleImpls, ...(obj.impls ?? [])];
     }
     else if (typeof obj === "number") {
         tag = "&core-number-methods";
@@ -1857,6 +1859,14 @@ function lookup_impls(obj) {
         tag = "&core-fn-methods";
         impls = normalize_builtin_impls(calcit_builtin_impls.fn);
     }
+    else if (obj == null ||
+        typeof obj === "boolean" ||
+        obj instanceof CalcitTag ||
+        obj instanceof CalcitSymbol ||
+        obj instanceof CalcitCirruQuote) {
+        tag = "&core-scalar-impls";
+        impls = normalize_builtin_impls(calcit_builtin_impls.scalar);
+    }
     else {
         return null;
     }
@@ -1997,7 +2007,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.origin != null && impl.origin.name.value === traitDef.name.value) {
+        if (impl != null && impl.origin === traitDef) {
             const fn = impl.getOrNil(methodName);
             if (fn != null) {
                 if (typeof fn !== "function") {

package/lib/package.json

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

package/package.json

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