@calcit/procs 0.13.6 → 0.13.7

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/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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.13.6",
+    "version": "0.13.7",
     "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.7",
   "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",