@calcit/procs 0.13.6 → 0.13.8

package/build.rs

@@ -79,12 +79,22 @@ pub struct CodeEntry {
   #[serde(default)]
   pub examples: Vec<Cirru>,
   #[serde(default)]
+  pub tests: Vec<TestEntry>,
+  #[serde(default)]
   pub tags: Vec<String>,
   pub code: Cirru,
   #[serde(default)]
   pub schema: Option<Edn>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct TestEntry {
+  pub name: String,
+  pub code: Cirru,
+  #[serde(default)]
+  pub tags: Vec<String>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct NsEntry {
   pub doc: String,
@@ -355,7 +365,7 @@ fn validate_schema_edn_no_legacy_quotes(value: &Edn, owner: &str) -> Result<(),
   walk(value, owner, &mut path)
 }
 
-fn parse_tags_from_edn(value: &Edn, owner: &str) -> Result<Vec<String>, String> {
+fn parse_tags_from_edn(value: &Edn, owner: &str, field: &str) -> Result<Vec<String>, String> {
   match value {
     Edn::Set(set) => {
       let mut tags = Vec::with_capacity(set.0.len());
@@ -363,10 +373,7 @@ fn parse_tags_from_edn(value: &Edn, owner: &str) -> Result<Vec<String>, String>
         match item {
           Edn::Tag(tag) => tags.push(format!(":{}", tag.ref_str())),
           other => {
-            return Err(format!(
-              "{owner}: CodeEntry.tags expects tag items, got {}",
-              format_edn_preview(other)
-            ));
+            return Err(format!("{owner}: {field} expects tag items, got {}", format_edn_preview(other)));
           }
         }
       }
@@ -374,10 +381,7 @@ fn parse_tags_from_edn(value: &Edn, owner: &str) -> Result<Vec<String>, String>
       tags.dedup();
       Ok(tags)
     }
-    other => Err(format!(
-      "{owner}: CodeEntry.tags expects a hashset, got {}",
-      format_edn_preview(other)
-    )),
+    other => Err(format!("{owner}: {field} expects a hashset, got {}", format_edn_preview(other))),
   }
 }
 
@@ -388,6 +392,7 @@ fn parse_code_entry(edn: Edn, owner: &str) -> Result<CodeEntry, String> {
   };
   let mut doc = String::new();
   let mut examples: Vec<Cirru> = vec![];
+  let mut tests: Vec<TestEntry> = vec![];
   let mut tags: Vec<String> = Vec::new();
   let mut code: Option<Cirru> = None;
   let mut schema: Option<Edn> = None;
@@ -395,7 +400,24 @@ fn parse_code_entry(edn: Edn, owner: &str) -> Result<CodeEntry, String> {
     match key.arc_str().as_ref() {
       "doc" => doc = from_edn(value.clone()).map_err(|e| format!("{owner}: invalid `:doc`: {e}"))?,
       "examples" => examples = from_edn(value.clone()).map_err(|e| format!("{owner}: invalid `:examples`: {e}"))?,
-      "tags" => tags = parse_tags_from_edn(value, owner)?,
+      "tests" => {
+        let Edn::List(items) = value else {
+          return Err(format!("{owner}: `:tests` expects a list, got {}", format_edn_preview(value)));
+        };
+        tests = items
+          .0
+          .iter()
+          .cloned()
+          .map(|item| parse_test_entry(item, owner))
+          .collect::<Result<Vec<_>, _>>()?;
+        let mut names = std::collections::HashSet::new();
+        for test in &tests {
+          if !names.insert(test.name.as_str()) {
+            return Err(format!("{owner}: duplicate test name `{}`", test.name));
+          }
+        }
+      }
+      "tags" => tags = parse_tags_from_edn(value, owner, "CodeEntry.tags")?,
       "code" => code = Some(from_edn(value.clone()).map_err(|e| format!("{owner}: invalid `:code`: {e}"))?),
       "schema" if !matches!(value, Edn::Nil) => {
         schema = Some(parse_schema_from_edn(value, owner).map_err(|e| format!("{owner}: invalid `:schema`: {e}"))?);
@@ -406,12 +428,40 @@ fn parse_code_entry(edn: Edn, owner: &str) -> Result<CodeEntry, String> {
   Ok(CodeEntry {
     doc,
     examples,
+    tests,
     tags,
     code: code.ok_or_else(|| format!("{owner}: missing `:code` field in CodeEntry"))?,
     schema,
   })
 }
 
+fn parse_test_entry(edn: Edn, owner: &str) -> Result<TestEntry, String> {
+  let struct_value = match edn {
+    Edn::Struct(value) => value,
+    other => return Err(format!("{owner}: expected TestEntry struct, got {}", format_edn_preview(&other))),
+  };
+  let mut name = None;
+  let mut code = None;
+  let mut tags = Vec::new();
+  for (key, value) in &struct_value.pairs {
+    match key.ref_str() {
+      "name" => name = Some(from_edn(value.clone()).map_err(|error| format!("{owner}: invalid test `:name`: {error}"))?),
+      "code" => code = Some(from_edn(value.clone()).map_err(|error| format!("{owner}: invalid test `:code`: {error}"))?),
+      "tags" => tags = parse_tags_from_edn(value, owner, "TestEntry.tags")?,
+      _ => {}
+    }
+  }
+  let name: String = name.ok_or_else(|| format!("{owner}: test is missing `:name`"))?;
+  if name.trim().is_empty() {
+    return Err(format!("{owner}: test name must not be empty"));
+  }
+  Ok(TestEntry {
+    name,
+    code: code.ok_or_else(|| format!("{owner}: test is missing `:code`"))?,
+    tags,
+  })
+}
+
 fn parse_ns_entry(edn: Edn, owner: &str) -> Result<NsEntry, String> {
   let struct_value: EdnStructView = match edn {
     Edn::Struct(r) => r,

package/editing-history/202608090140-record-tuple-to-struct-enum.md

@@ -0,0 +1,38 @@
+# Migrate remaining record/tuple naming to struct/enum
+
+Follow-up to the earlier terminology migration: located and updated the
+remaining stale `record`/`tuple` naming that refers to the current
+struct/enum data model, keeping genuine legacy-compat and EDN semantics.
+
+## Updated
+
+- `calcit/test-wasm.cirru`: renamed `test-record-*` → `test-struct-*` and
+  `test-tuple-*` → `test-enum-*` (incl. `test-type-of-tuple` →
+  `test-type-of-enum`) via `cr edit rename`; updated 12 doc strings. Kept
+  `defrecord Point :x :y` as the WASM legacy-compat coverage.
+- `scripts/test-wasm.mjs`: synced the renamed def references and section
+  labels.
+- `src/runner/preprocess/mod.rs`: test-namespace labels `tests.record` →
+  `tests.struct` (kept the legacy `record` tag coverage in the loose-struct
+  test).
+- `src/builtins/meta.rs`: `Calcit::Enum(tuple)` local bindings →
+  `enum_value`.
+- `src/codegen/emit_wasm.rs`: comments `tuple fields`/`tuple pointer` →
+  `enum fields`/`enum pointer`.
+- `src/bin/cli_handlers/query.rs`: test message `tuple operations` →
+  `enum operations`.
+
+## Deliberately kept
+
+- Legacy migration tables in `docs/`, `deprecated_api.rs`, and
+  `removed_data_api_replacement`.
+- Type-name aliases (`record`/`tuple` → Struct/Enum parsing), `SIMPLE_TYPES`
+  `tuple` query name, and IR/format-stable kind tags.
+- `cirru_edn` `Edn::Record`/`Edn::Enum` contexts and hash prefixes.
+
+Validation:
+
+- `cargo test -q`（368 lib + 192 integration）
+- `cargo clippy --lib --bin cr -- -D warnings`
+- `cargo fmt --check`
+- `yarn try-wasm`（含重命名后的 `test-struct-*` / `test-enum-*`）

package/editing-history/202608091056-import-rule-cli-regression.md

@@ -0,0 +1,15 @@
+# Import rule CLI regression coverage
+
+- Added direct handler regressions for `cr edit imports` and
+  `cr edit add-import` when an import rule has the wrong arity.
+- Both tests assert the indexed validation diagnostic and verify that the
+  snapshot remains byte-for-byte unchanged after rejection.
+- This protects the persistence boundary in addition to the existing
+  `validate_import_rules` unit coverage.
+
+Validation:
+
+- `cargo fmt`
+- `cargo clippy --bin cr -- -D warnings`
+- `cargo test --bin cr` (194 passed)
+- `git diff --check`

package/editing-history/202608091119-import-rule-review-followup.md

@@ -0,0 +1,12 @@
+# Import rule regression review follow-up
+
+- Changed the malformed-import persistence assertions to compare raw file
+  bytes instead of UTF-8 strings, matching the byte-for-byte guarantee and
+  keeping the tests independent of snapshot text encoding.
+
+Validation:
+
+- `cargo fmt`
+- `cargo clippy --bin cr -- -D warnings`
+- `cargo test --bin cr malformed_rule`
+- `git diff --check`

package/editing-history/202608091700-definition-attached-core-tests.md

@@ -0,0 +1,43 @@
+# Definition-attached core tests: consolidated history
+
+This development window introduced and completed definition-attached tests in
+`src/cirru/calcit-core.cirru`, so pure `calcit.core` API contracts can run from
+the definition that implements them while target-specific and integration
+coverage remains in the legacy fixtures.
+
+## Durable design decisions
+
+- Added backward-compatible `:tests` metadata and embedded `calcit.test`
+  assertions (`is`, `is=`, `is-not=`, `throws?`, `is-throws`, and `fail`).
+- `cr test` discovers named tests with namespace, definition, name, and tag
+  filters, supports list/fail-fast/JSON modes, and uses conservative static
+  dependency analysis for `--affected` selection.
+- Unscoped `cr test` stays project-local to the namespaces in the input
+  snapshot; core tests are run explicitly (including by CI) so external
+  projects do not execute `calcit.core` tests accidentally.
+- Ordinary test execution preprocesses lazily, while `--affected` builds its
+  static candidate index once. This keeps fail-fast and normal runs from
+  compiling tests that will not execute.
+- Migrated pure guards for collection, string, parsing, numeric, math, set,
+  destructuring, and update APIs into `calcit.core` definitions. Removed their
+  duplicate assertions from `calcit/test-*.cirru` while retaining method,
+  macro, type/preprocess, multi-definition, JavaScript, and WASM fixtures.
+- CI and release workflows explicitly run the embedded core suite. A compact
+  JavaScript fixture remains for target-specific bitwise execution.
+- Review fixes standardized whitespace/duplicate test-name validation,
+  preserved empty JSON report envelopes on selection errors, corrected built-in
+  `query tests` behavior and affected-test diagnostics, executed the
+  `test-comma` fixture, corrected `&map:diff-new` documentation, and removed
+  25 duplicate or strict-subset attached tests. The final core suite contains
+  166 tests.
+
+## Verification
+
+- `yarn try-core-tests` (166 passed)
+- `yarn try-rs` and `yarn try-js`
+- `yarn check-all` (core, native, JavaScript, IR, WASM, and agent interface)
+- `cargo fmt`, `cargo clippy -- -D warnings`, `cargo test`, `yarn compile`
+- JSON test output remains one parseable report envelope.
+
+The detailed per-commit notes were merged into this record; their exact text
+remains recoverable from Git history.

package/editing-history/202608091723-migrate-set-string-number-method-tests.md

@@ -0,0 +1,21 @@
+# Migrate set, string, and number method tests
+
+Move deterministic set, string, and number method assertions from the legacy
+`calcit/test-*.cirru` fixtures to definition-attached tests in
+`src/cirru/calcit-core.cirru`.
+
+- Cover the internal set and string primitives at their implementation entries,
+  including Unicode character indexing and slicing.
+- Add the remaining public numeric `empty` and `inc` checks at their definitions.
+- Correct `&number:format` metadata to declare its required decimal-place
+  argument, which the migrated test made explicit.
+- Delete the redundant `test-methods` blocks from the set, math, and string
+  fixtures. Keep a compact set method-dispatch smoke check plus the existing
+  target-specific, eval, formatting, Unicode, and WASM coverage.
+
+Validation:
+
+- `yarn try-core-tests` (210 passed)
+- `target/debug/cr calcit/test-set.cirru`
+- `target/debug/cr calcit/test-math.cirru`
+- `target/debug/cr calcit/test-string.cirru`

package/editing-history/202608091745-cr-edit-accuracy-and-output.md

@@ -0,0 +1,34 @@
+# Improve cr edit accuracy and output
+
+Recent definition-test migrations exposed three CLI failure modes worth fixing:
+
+- Running a source `calcit-core.cirru` through an older `cr` binary silently
+  replaced its `calcit.core` namespace with the binary's embedded snapshot.
+- Numeric tree paths could still point at a valid adjacent node, allowing a
+  delete or insertion to succeed at the wrong location.
+- Tree mutations repeated the same before/after fragments, command echoes
+  included every inactive default, and the core suite printed hundreds of PASS
+  rows during the normal repository gate.
+
+Changes:
+
+- Preserve namespaces supplied by the input snapshot while filling only missing
+  core namespaces from the embedded snapshot.
+- Add optional quoted-Cirru/JSON `--expect` guards to path-based replace,
+  delete, and insert operations. A mismatch fails before the snapshot is saved.
+- Include non-default snapshot paths and all active test filters in command
+  echoes. Hide inactive/default options unless `--verbose` is requested.
+- Remove duplicated tree insertion/deletion previews, honor `--depth`, and show
+  the actually modified container after child insertion. Run
+  `yarn try-core-tests` with `--summary-only`; summary mode also suppresses
+  program output from intentionally failing assertion tests.
+
+Focused validation:
+
+- Unit tests for exact/mismatched node guards and source-core precedence.
+- A guarded deletion with the wrong expected node exited unsuccessfully and
+  preserved the temporary snapshot SHA-256.
+- A temporary source core containing one extra test ran 211 tests while the
+  binary embedded 210, proving the source namespace won.
+- `cargo fmt --check`, `cargo clippy -- -D warnings`, `cargo test`,
+  `yarn compile`, `yarn check-agent-interface`, and `yarn check-all` passed.

package/editing-history/202608091745-internal-method-and-proc-test-migration.md

@@ -0,0 +1,21 @@
+# Internal method and proc test migration
+
+- Added 19 definition-attached `:unit :core` tests beside list and map method
+  implementations, including `&list:find-last`, `&list:find-last-index`,
+  `&list:map`, `&list:map-pair`, sorting, direct list primitives, map filters,
+  mapping, association, removal, emptiness, values, and pair conversion.
+- Attached tests directly to Rust-backed core procs such as `&list:first`,
+  `&list:nth`, `&list:sort`, `&map:vals`, and `&map:to-list`. These tests verify
+  the proc contract in the core snapshot; backend-specific execution remains in
+  the JS/WASM fixtures.
+- Removed the duplicated pure method assertion blocks from `calcit/test-list.cirru`
+  and `calcit/test-map.cirru`. Kept list shorthand method coverage and the
+  remaining method/type/backend integration fixtures.
+
+Validation:
+
+- `yarn try-core-tests` (186 passed)
+- `yarn check-all` (core, native, JavaScript, IR, WASM, and agent interface)
+- `cr calcit/test-list.cirru`, `cr calcit/test-map.cirru`, and
+  `cr calcit/test-string.cirru`
+- `git diff --check`

package/editing-history/202608091800-review-history-terminology.md

@@ -0,0 +1,8 @@
+# Review history terminology
+
+- Corrected the retained definition-attached-test history to use the standard
+  spelling “built-in” when referring to the `query tests` behavior.
+
+Validation:
+
+- `git diff --check`

package/editing-history/202608091812-release-0.13.7.md

@@ -0,0 +1,8 @@
+# Release 0.13.7
+
+Released the merged definition-attached core test and `cr` CLI accuracy work.
+
+- Bumped the Rust crate and npm package versions from `0.13.6` to `0.13.7`.
+- Updated `Cargo.lock` with the workspace version through `cargo update --workspace`.
+- Release validation covers the merged PR's core tests, native/JS/WASM targets,
+  Agent CLI interface, and the repository test workflow before tagging.

package/editing-history/202608091830-test-runner-selection-and-reporting.md

@@ -0,0 +1,23 @@
+# Test runner selection and reporting guardrails
+
+- Added `cr test --exclude-tag` so CI and agents can leave slow or integration
+  guards out of a focused run without weakening the default suite.
+- Added `--require-match` to make an empty scoped/tagged/affected selection fail
+  instead of producing an accidental green result.
+- Added `--summary-only` for compact large-suite output. JSON reports now state
+  `detail`, distinguish selected from executed tests, and include per-test
+  execution durations in full reports.
+- Kept test execution native-only. JS/WASM checks remain dedicated fixtures;
+  an in-process timeout was intentionally not added because the interpreter
+  cannot safely cancel a running test thread.
+
+Validation:
+
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `cargo test`
+- `yarn compile`
+- `yarn check-agent-interface`
+- `yarn check-all`
+- JSON summary and empty-selection CLI smoke checks
+- `git diff --check`

package/editing-history/202608092000-inspect-type-path-format.md

@@ -0,0 +1,4 @@
+# `&inspect-type` 坐标输出统一
+
+- 将 `&inspect-type` 诊断中的源码坐标从 `[@3.5.1]` 调整为 `@3.5.1`。
+- 复用统一的 `@` 路径格式，并增加 Rust 回归测试，避免方括号格式再次出现。

package/history/202608092318-enum-edn-option-diagnostics.md

@@ -0,0 +1,21 @@
+# Cirru EDN enum identity and Option migration diagnostics
+
+## 背景
+
+- GitHub #326 暴露 JS `format-cirru-edn` / `parse-cirru-edn` 往返后 enum variant 从 interned `CalcitTag` 变成 `CalcitSymbol`，导致生成的 `match` 按身份比较时无法命中。
+- GitHub #325 暴露 Option migration 诊断仍使用预处理前的 source symbol，普通 `=`, `some?`, `assoc` 等调用不会触发告警，并且 `starts-with?` / `ends-with?` 的 proc metadata 比公开 schema 更宽。
+
+## 修改与边界
+
+- JS Cirru EDN parser 在匿名和具名 enum 分支统一把解析出的 symbol variant 通过 `newTag` intern；quoted nominal name 也按 tag key 恢复 options map 中的 `CalcitEnumDef`。
+- Option migration diagnostics 改用预处理后的 `head_form` / `call_head`，避免漏掉普通 source syntax，同时继续区分应用自行定义的同名函数。
+- 结构操作诊断覆盖 `assoc`, `dissoc`, `merge`, `update` 及其 nested/non-nil variants。
+- `starts-with?` / `ends-with?` proc 参数 metadata 收紧为 `String × String`，与文档和 core schema 一致；旧 Tag runtime 兼容测试用显式 `unsafe-coerce` 标明边界。
+- 合法的 nominal enum equality 继续允许，包括类型推断尚未完成时，Option/Result constructor 和已声明返回 nominal enum 的调用之间的比较。
+
+## 验证
+
+- JS runtime identity check 覆盖匿名 enum、具名 enum prototype 恢复和 identity-based match 条件。
+- Rust end-to-end snippet test 覆盖 issue 中的 `get-env`, `some?`, `update-in/assoc`, `nth/starts-with?` 普通源码写法。
+- `cargo fmt --all`, `cargo clippy -- -D warnings`, `yarn compile`, `cargo test`, `yarn check-all` 全部通过。
+- 安装当前全局 `cr` 后在 Respo 执行 `cr --check-only`，成功在真实项目中报告 3 个 Option migration warning（另有 1 个既有 JS nullable warning），未进入相关运行时失败路径。

package/history/202608100022-required-struct-field-access.md

@@ -0,0 +1,46 @@
+# Required Struct field access
+
+## Background
+
+Field syntax previously changed its contract according to inferred receiver
+type: `(:field value)` returned the declared payload for a known Struct, but
+silently lowered to Option-producing `get` when the receiver looked like a Map
+or lost type information. This made local edits unstable: adding or losing a
+type annotation changed downstream control flow without changing source syntax.
+
+Issue #325 clarified that dynamic container absence and required model fields
+are different boundaries. AI-assisted edits need those boundaries to remain
+visible so diagnostics guide code toward a declared model instead of allowing
+`Dynamic`/`Option` patches to spread.
+
+## Contract
+
+- `(:field value)` is required access. The receiver must be a statically known
+  named Struct and the field must be declared. Its result is the declared field
+  type.
+- `get` and `get-in` are explicit partial lookup APIs for Map and indexed/path
+  access. They return nominal `Option<T>`.
+- `get` on a Struct is rejected with a diagnostic pointing to required field
+  syntax; the runtime also rejects dynamically hidden Struct receivers.
+- Loose/anonymous Struct field access is rejected until an expected named
+  Struct type rewrites or narrows it.
+- Low-level `&struct:get` remains available for internal dynamic boundaries
+  such as reusable trait implementation bodies.
+
+## Type inference details
+
+- `update` preserves the receiver's collection/Struct type.
+- `&struct:from-map` preserves the Struct definition supplied as its first
+  argument.
+- Struct pattern-match expansion is exempt from source field validation because
+  all nominal branches are preprocessed before runtime guards select a variant.
+
+## Diagnostics
+
+- `W_REQUIRED_STRUCT_FIELD_TYPE`: required field syntax lacks a named Struct
+  contract.
+- `W_UNKNOWN_STRUCT_FIELD`: a named Struct does not declare the requested field.
+- `W_STRUCT_FIELD_OPTIONAL_LOOKUP`: `get` is used on a Struct.
+
+Tests cover typed access, Map fallback rejection, unknown fields, `get` misuse,
+nominal type preservation, loose Struct access, and the existing Struct suite.

package/history/202608100102-docs-field-access-ci.md

@@ -0,0 +1,22 @@
+# Documentation validation for required Struct fields
+
+## Background
+
+The PR's local `yarn check-all` suite passed, but GitHub's Test workflow also
+runs `scripts/check-docs-md.sh`. Several executable documentation snippets
+still relied on the former context-sensitive field syntax.
+
+## Documentation migration
+
+- Map reads that branch on absence retain their `Option` value for `tag-match`
+  instead of unwrapping it first.
+- Generic enum payloads, local trait implementations, generic Struct bodies,
+  and anonymous Struct examples use explicit `&struct:get` when their receiver
+  has no statically resolvable named Struct declaration.
+- Snapshot/schema fragments now use standard `cirru.edn` fences with valid
+  EDN roots and quoted symbols, so `check-md` validates them as data instead
+  of evaluating tags such as `:entries` or `:where` as required field access.
+
+## Verification
+
+- `bash scripts/check-docs-md.sh`: 54 files, 286 blocks, all passed.

package/history/202608100145-cirru-edn-doc-fences.md

@@ -0,0 +1,17 @@
+# Standard Cirru EDN documentation fences
+
+## Background
+
+Executable documentation fences use the standard `cirru.edn` marker. The
+non-standard `cirru-edn` spelling bypassed EDN validation and hid malformed
+configuration and schema fragments.
+
+## Change
+
+- Replaced all newly introduced `cirru-edn` fences with `cirru.edn`.
+- Wrapped standalone configuration/schema fields in top-level EDN maps.
+- Quoted symbolic trait references inside EDN schema values.
+
+## Verification
+
+- `bash scripts/check-docs-md.sh`: 54 files and 290 blocks passed.

package/history/202608100339-struct-path-boundaries.md

@@ -0,0 +1,11 @@
+## Struct path API boundaries
+
+- Public collection path APIs (`get-in`, `assoc-in`, `update-in`, `dissoc-in`)
+  now stop at nominal Struct boundaries. Required fields remain visible as direct
+  `(:field value)` accesses, preserving their declared types for the checker.
+- The preprocessor diagnoses literal and dynamic paths that would enter a Struct;
+  `get-in` no longer infers a field type through such a path.
+- Runtime core implementations reject the same traversal after a Dynamic boundary,
+  so unsafe coercion cannot silently bypass the typed field-access contract.
+- Updated the type-inference fixture to use nested direct field access instead of
+  `get-in` across a Struct.

package/history/202608100348-caps-branch-checkout.md

@@ -0,0 +1,8 @@
+## caps remote branch checkout
+
+- `caps` now fetches remote branch refs as well as tags when resolving an
+  existing module clone.
+- If a requested branch exists only as `origin/<branch>`, checkout now creates
+  a local tracking branch instead of failing after the fetch succeeds.
+- This keeps branch-based module integration reproducible through `caps
+  download`, without manually editing the module cache.

package/history/202608100349-caps-remote-branch-reset.md

@@ -0,0 +1,8 @@
+## caps remote branch checkout hardening
+
+- Existing module clones can use narrow or non-standard remote refspecs, for
+  which `git checkout --track origin/<branch>` may reject an otherwise fetched
+  remote ref.
+- `caps` now creates/resets the requested local branch with `git checkout -B
+  <branch> origin/<branch>`, keeping branch-based module downloads reliable and
+  compatible with later `--pull-branch` updates.

package/history/202608100959-struct-path-review-followups.md

@@ -0,0 +1,11 @@
+## Struct path-operation review follow-ups
+
+- `contains-in?` now follows the same Struct boundary as the other collection
+  path APIs: a path may not enter a declared Struct field. Direct typed field
+  access keeps required-field diagnostics and return types precise.
+- The preprocessor reports `W_STRUCT_PATH_OPERATION` for `contains-in?`, with
+  a regression test covering all five path APIs.
+- Runtime guidance for `dissoc-in` now explains that declared Struct fields
+  cannot be removed; model optionality explicitly or convert to a map first.
+- Module ref fetching now uses `--prune`, so stale remote-tracking branches do
+  not remain selectable after an upstream branch deletion.

package/history/202608101042-release-0.13.8.md

@@ -0,0 +1,6 @@
+## Release 0.13.8
+
+- Publishes the typed Struct field-access and collection path-boundary work
+  merged through PR #327.
+- Keeps module branch resolution robust by fetching and pruning remote branch
+  refs before checkout.

package/lib/calcit.procs.d.mts

@@ -23,6 +23,7 @@ export declare const calcit_package_json: {
         "check-all": string;
         "check-agent-interface": string;
         "try-all": string;
+        "try-core-tests": string;
         "try-rs": string;
         "warn-dyn-method": string;
         "try-js-brk": string;

package/lib/js-cirru.mjs

@@ -225,13 +225,17 @@ let recordFieldOrder = (a, b) => {
 };
 /** makes sure we got string */
 let extractFieldTag = (x) => {
-    if (x[0] === ":") {
+    if (x[0] === ":" || x[0] === "'") {
         return newTag(x.slice(1));
     }
     else {
         return newTag(x);
     }
 };
+let extractEnumTag = (x, options, preserveSourceEntries) => {
+    const parsedTag = extract_cirru_edn_inner(x, options, preserveSourceEntries);
+    return parsedTag instanceof CalcitSymbol ? newTag(parsedTag.value) : parsedTag;
+};
 let resolveEnumPrototype = (enumName, options) => {
     if (options instanceof CalcitMap || options instanceof CalcitSliceMap) {
         let value = options.get(extractFieldTag(enumName));
@@ -412,7 +416,7 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
             if (x.length < 2) {
                 throw new Error(`anonymous enum expects at least 1 value, got: ${x}`);
             }
-            return new CalcitEnumValue(extract_cirru_edn_inner(x[1], options, preserveSourceEntries), x
+            return new CalcitEnumValue(extractEnumTag(x[1], options, preserveSourceEntries), x
                 .slice(2)
                 .filter(notComment)
                 .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries)));
@@ -426,10 +430,7 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
                 throw new Error(`Expected string for enum name, got: ${enumName}`);
             }
             let enumPrototype = resolveEnumPrototype(enumName, options);
-            // unwrap prototype to record then extract name
-            const proto = enumPrototype != null ? unwrap_enum_prototype_local(enumPrototype) : null;
-            const enumTag = proto != null ? proto.name.toString() : enumName;
-            return new CalcitEnumValue(extract_cirru_edn_inner(x[2], options, preserveSourceEntries), x
+            return new CalcitEnumValue(extractEnumTag(x[2], options, preserveSourceEntries), x
                 .slice(3)
                 .filter(notComment)
                 .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries)), enumPrototype);

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.13.6",
+    "version": "0.13.8",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.7.0",
@@ -19,9 +19,10 @@
         "check-js-runtime": "node scripts/check-js-runtime-identity.mjs",
         "bench-recur-smoke": "cargo run --bin cr -- calcit/test.cirru js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
         "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-        "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
+        "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-core-tests && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
         "check-agent-interface": "cargo build --bin cr && node scripts/check-agent-interface.mjs",
         "try-all": "yarn check-all",
+        "try-core-tests": "cargo run --bin cr -- src/cirru/calcit-core.cirru test --tag unit --summary-only",
         "try-rs": "cargo run --bin cr -- calcit/test.cirru",
         "warn-dyn-method": "cargo run --bin cr -- calcit/test.cirru --warn-dyn-method",
         "try-js-brk": "cargo run --bin cr -- calcit/test.cirru js && node --inspect-brk js-out/main.mjs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.13.6",
+  "version": "0.13.8",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.7.0",
@@ -19,9 +19,10 @@
     "check-js-runtime": "node scripts/check-js-runtime-identity.mjs",
     "bench-recur-smoke": "cargo run --bin cr -- calcit/test.cirru js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
     "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-    "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
+    "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-core-tests && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
     "check-agent-interface": "cargo build --bin cr && node scripts/check-agent-interface.mjs",
     "try-all": "yarn check-all",
+    "try-core-tests": "cargo run --bin cr -- src/cirru/calcit-core.cirru test --tag unit --summary-only",
     "try-rs": "cargo run --bin cr -- calcit/test.cirru",
     "warn-dyn-method": "cargo run --bin cr -- calcit/test.cirru --warn-dyn-method",
     "try-js-brk": "cargo run --bin cr -- calcit/test.cirru js && node --inspect-brk js-out/main.mjs",

package/ts-src/js-cirru.mts

@@ -220,13 +220,18 @@ let recordFieldOrder = (a: [string, CirruEdnFormat], b: [string, CirruEdnFormat]
 
 /** makes sure we got string */
 let extractFieldTag = (x: string) => {
-  if (x[0] === ":") {
+  if (x[0] === ":" || x[0] === "'") {
     return newTag(x.slice(1));
   } else {
     return newTag(x);
   }
 };
 
+let extractEnumTag = (x: CirruEdnFormat, options: CalcitValue, preserveSourceEntries: boolean): CalcitValue => {
+  const parsedTag = extract_cirru_edn_inner(x, options, preserveSourceEntries);
+  return parsedTag instanceof CalcitSymbol ? newTag(parsedTag.value) : parsedTag;
+};
+
 let resolveEnumPrototype = (enumName: string, options: CalcitValue) => {
   if (options instanceof CalcitMap || options instanceof CalcitSliceMap) {
     let value = options.get(extractFieldTag(enumName));
@@ -405,7 +410,7 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
         throw new Error(`anonymous enum expects at least 1 value, got: ${x}`);
       }
       return new CalcitEnumValue(
-        extract_cirru_edn_inner(x[1], options, preserveSourceEntries),
+        extractEnumTag(x[1], options, preserveSourceEntries),
         x
           .slice(2)
           .filter(notComment)
@@ -421,11 +426,8 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
         throw new Error(`Expected string for enum name, got: ${enumName}`);
       }
       let enumPrototype = resolveEnumPrototype(enumName, options);
-      // unwrap prototype to record then extract name
-      const proto = enumPrototype != null ? unwrap_enum_prototype_local(enumPrototype) : null;
-      const enumTag = proto != null ? proto.name.toString() : enumName;
       return new CalcitEnumValue(
-        extract_cirru_edn_inner(x[2], options, preserveSourceEntries),
+        extractEnumTag(x[2], options, preserveSourceEntries),
         x
           .slice(3)
           .filter(notComment)