@calcit/procs 0.13.43 → 0.13.45

package/editing-history/20260825-2338-core-structural-macro-contracts.md

@@ -0,0 +1,10 @@
+# Core structural macro contracts
+
+- Migrated `let`, `fn`, `and`, `cond`, and `do` from whole-Dynamic legacy
+  schemas to strict, compile-time-pure phase contracts.
+- Kept expansion values as `Expr<Dynamic>` where the result depends on user
+  code, while enforcing list-shaped binding/argument/condition syntax.
+- Canonicalized strict Macro storage with explicit empty capability sets and
+  added snapshot assertions so the migrated set cannot silently regress.
+- The Calcit test snapshot now exposes 895 strict/pure expansion candidates in
+  the measured run (up from 4), while preserving all 2,432 expansions.

package/editing-history/20260825-2356-delayed-macro-metrics-review.md

@@ -0,0 +1,5 @@
+# Delayed macro metrics review
+
+- Clarified that `cacheHits` and `cacheInvalidations` are reserved report fields until the expansion cache is implemented.
+- Made the metrics report unit test operate on local state, avoiding interference with global opt-in metrics state when Rust tests run in parallel.
+- Kept production collection behavior unchanged by extracting small state-local recording and serialization helpers.

package/editing-history/202608252220-phase-aware-macro-signatures.md

@@ -0,0 +1,35 @@
+# Phase-aware macro signatures
+
+Implemented roadmap issue #434 after the parameter-shape diagnostics from
+#433/#438 landed.
+
+- Added a dedicated `MacroSignature` model instead of representing macros as
+  runtime `CalcitFnTypeAnnotation` values.
+- Split raw inputs into `Syntax`, `SyntaxSymbol`, `SyntaxList`, and `Expr<T>`;
+  split expansion results into `Expr<T>`, `Definition<T>`, and `Declarations`.
+- Added required, optional, rest, generic, where-bound, and feature metadata.
+- Preserved old `Macro {:args ... :return ...}` snapshots as explicit legacy,
+  non-strict signatures; the ordinary Fn parser rejects strict macro fields.
+- Attached signatures to materialized `CalcitMacro` values, typed macro-body
+  locals at syntax phase, and added separate call-input and expansion-result
+  diagnostics with source locations and macro stacks.
+- Updated snapshot, detailed snapshot, weak-type, and coverage paths so the new
+  model survives all formats and contributes accurate coverage.
+- Migrated core `%{}?` to `SyntaxSymbol + & SyntaxList -> Expr<Struct>` and
+  documented Respo `defstyle` as the declaration-output case study.
+
+Validation performed:
+
+- `cargo fmt`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test`
+- `yarn compile`
+- `yarn check-all`
+- `yarn check-agent-interface`
+- `calcit docs check-md --entry src/cirru/calcit-core.cirru docs/MacroSignature.md`
+- latest Respo main: 27/27 tests and 126/126 documentation blocks
+- latest Recollect main: 9/9 Calcit tests plus JS tests
+
+External regressions used globally installed Calcit 0.13.44 and refreshed
+`@calcit/procs` 0.13.44; stale local 0.13.27 packages were replaced before the
+final run.

package/editing-history/202608252249-macro-compile-time-capabilities.md

@@ -0,0 +1,27 @@
+# Macro compile-time capabilities
+
+Issue #435 adds an enforceable effect boundary around strict macro execution.
+The capability policy is centralized in `runner::macro_capability` and remains
+active through ordinary helper calls by using a scoped evaluator context.
+
+Strict `MacroSignature` values now serialize a dedicated `:capabilities`
+hashset. Pure expansion needs no declaration. Environment, filesystem,
+platform, clock, mutable-state, and dynamic-eval reads/actions may be declared;
+filesystem writes, process control, and host FFI are classified but always
+rejected. Legacy macro signatures stay compatible, but their effects remain
+unknown and they are not eligible for future pure-expansion caching.
+
+The evaluator checks builtin procedures, state/dynamic-eval syntax, native
+methods, registered procedures, and raw host code. Missing declarations use
+`E_MACRO_CAPABILITY_MISSING`; forbidden operations use
+`E_MACRO_CAPABILITY_DISALLOWED`. Both preserve the macro call location and
+helper chain. Quoted code that performs an effect later at runtime remains a
+pure expansion. Macro diagnostics also reuse the raw call-head location instead
+of the locationless resolved import, preserving no-argument call sites.
+
+Validation covered formatting, clippy, all Rust and CLI tests, native/JS/IR/WASM
+integration, agent-interface checks, and the macro-signature documentation.
+Latest Respo passed 27 tests and 126 documentation blocks. Latest Recollect
+passed 9 native tests plus JS and WASM regressions. Its production build still
+reports the existing Respo DOM FFI and `:unit`/`:nil` warning baseline; neither
+external repository was modified.

package/editing-history/20260826-0007-assertion-macro-contracts.md

@@ -0,0 +1,8 @@
+# Assertion macro contracts
+
+- Migrated the three `calcit.core` assertion macros and five `calcit.test` helpers to strict, pure phase-aware contracts.
+- Kept input values as `Expr<Dynamic>` because equality and truthiness intentionally accept heterogeneous runtime values.
+- Declared precise expansion results: `Expr<Unit>` for assertion helpers and `Expr<Bool>` for `throws?`.
+- Added the missing successful `&unit` branch to `assert=` so its implementation matches its long-standing Unit contract.
+- Added snapshot coverage and exercised definition-attached tests plus public examples.
+- On `calcit/test.cirru`, strict/pure macro candidates increased from 895 to 1,666 while total expansions stayed at 2,432.

package/editing-history/20260826-0023-assertion-macro-review.md

@@ -0,0 +1,4 @@
+# Assertion macro review
+
+- Strengthened the real Snapshot inventory test to assert the exact required input count for each `calcit.test` assertion helper.
+- Kept the original history timestamp because the commit was created at `2026-08-26 00:13:33 +0800`; the review bot compared against the previous UTC date.

package/editing-history/20260826-0038-control-flow-macro-contracts.md

@@ -0,0 +1,9 @@
+# Control-flow macro contracts
+
+- Migrated `or`, `either`, `when`, `when-not`, `if-not`, `if-let`, and `when-let` to strict, pure phase-aware contracts.
+- Preserved expression-level Dynamic boundaries where branch value types intentionally vary, while declaring `when-let` as `Expr<Option<Dynamic>>`.
+- Corrected the `or false nil` example to expect the final falsey value (`nil`) and clarified that behavior in its documentation.
+- Fixed strict macro body parameter typing: `SyntaxList` is represented as a list, `SyntaxSymbol` as a symbol, and rest bindings as lists of their declared syntax element type.
+- Added regression coverage for strict macro body parameter representations and the real core Snapshot inventory.
+- Increased strict macro coverage in `calcit/test.cirru` from 1666 to 1805 of 2432 expansions.
+- Verified the release compiler against Respo `be8141e` (27 tests and check-only JS) and Recollect `6c235d0` (9 native tests plus JS/Node tests).

package/editing-history/20260826-0100-review-exact-control-flow-contracts.md

@@ -0,0 +1,5 @@
+# Exact control-flow contract regression checks
+
+- Strengthened the core Snapshot inventory to assert each migrated control-flow macro's exact required, optional, and rest syntax contracts.
+- Asserted exact expansion types, including `when-let` as `Expr<Option<Dynamic>>` and the remaining macros as `Expr<Dynamic>`.
+- Documented the strict macro body type helpers added by the original change.

package/editing-history/20260826-0120-pattern-macro-contracts.md

@@ -0,0 +1,8 @@
+# Pattern-matching macro contracts
+
+- Migrated `tag-match`, `list-match`, `struct-match`, `case`, and their internal expansion helpers to strict, compile-time-pure macro contracts.
+- Kept branch bodies as `SyntaxList`; retained `list-match`'s heterogeneous public argument sequence as an intentional `Syntax` rest boundary while typing its internal helper exactly.
+- Corrected the pre-existing `tag-match` example expectation from `got:hello` to `hello:got`, matching `str x |:got`.
+- Added exact Snapshot assertions for required, optional, rest, capability, and expansion contracts across both `calcit.core` and `calcit.internal`.
+- Increased strict macro coverage in `calcit/test.cirru` from 1805 to 1949 of 2432 expansions.
+- Verified all repository gates plus Respo `be8141e`, Recollect `6c235d0`, and js-ffi `25869b6`; js-ffi dependencies were reinstalled from its 0.13.44 lockfile before Node/browser contract tests.

package/editing-history/20260826-0133-collection-macro-contracts.md

@@ -0,0 +1,9 @@
+# Collection macro contracts
+
+- Migrated `{}`, `%{}`, and `{,}` to strict, compile-time-pure macro contracts.
+- Declared map literal expansions as `Expr<Map<Dynamic, Dynamic>>` and struct literal expansion as `Expr<Struct>`.
+- Kept pair-oriented inputs as `SyntaxList` and the flat comma-filtering `{,}` body as an intentional raw `Syntax` rest boundary.
+- Corrected the pre-existing `%{}` example to use field pairs `(:x 1)` and `(:y 2)` rather than list-constructor calls that introduced extra fields.
+- Added exact Snapshot assertions for each macro's input and expansion contracts.
+- Increased strict macro coverage in `calcit/test.cirru` from 1949 to 2133 of 2432 expansions.
+- Verified all repository gates plus Respo `be8141e`, Recollect `6c235d0`, and js-ffi `25869b6` with the current compiler.

package/editing-history/20260826-0152-definition-macro-contracts.md

@@ -0,0 +1,25 @@
+# Definition-value macro contracts
+
+## Changes
+
+- Migrated `def` to a pure phase-aware macro contract with a symbol declaration name and an explicit dynamic expression boundary.
+- Migrated `deftrait`, `defstruct`, `defimpl`, and `defenum` to strict syntax-input contracts with precise `Trait`, `StructDef`, `Impl`, and `EnumDef` expression outputs.
+- Kept symbol/tag compatibility for data-definition names by using unrestricted syntax for those positions; method and field forms use list syntax where the macro requires pair/list forms.
+- Added Snapshot assertions for required, optional, rest, capability, and expansion fields so serialization regressions cannot silently weaken these contracts.
+
+## Semantic finding
+
+Although these macros generate top-level definition values, the core `def` macro is consumed before the outer expansion-result check. Their observable expansion contract is therefore `Expr<T>`, not `Definition<T>`. Using `Definition<T>` fails against the real core corpus because the checked form is already `&trait::new`, `&struct-def:new`, `&impl::new`, or `&enum-def:new`.
+
+## Validation
+
+- Core strict macro expansions: `2133/2432` -> `2341/2432`; legacy bypasses: `299` -> `91`.
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `yarn compile`
+- `cargo test`
+- `yarn check-all`
+- `yarn check-agent-interface`
+- Respo `be8141e`: 27 definition-attached tests and JS check-only passed.
+- Recollect `6c235d0`: 9 unit tests, JS generation, and Node runtime passed.
+- js-ffi `25869b6`: default/node/browser checks plus Node and browser-node contracts passed.

package/editing-history/20260826-0203-transform-macro-contracts.md

@@ -0,0 +1,28 @@
+# Transform macro contracts
+
+## Changes
+
+- Migrated `->`, `->%`, and `%<-` with phase-aware base/step contracts.
+- Migrated `apply-args` and `flipped` with callable input contracts and explicit dynamic result boundaries.
+- Migrated anonymous function shorthands `\` and `\.` with syntax inputs and callable expression outputs.
+- Migrated `[,]` with arbitrary syntax inputs and a `List<Dynamic>` expression output.
+- Added exact Snapshot assertions for every required, optional, rest, capability, and expansion field.
+
+## Contract notes
+
+- Thread steps in `->` remain unrestricted syntax because the macro deliberately accepts symbol, tag, method, function, and list forms.
+- Calcit's canonical callable schema type is `'Fn`; `'DynFn` is not the public schema spelling.
+- `%<-`, `\`, and `[,]` retain runtime empty-input diagnostics because their implementation uses rest-only parameters and the phase signature mirrors that actual binder shape.
+
+## Validation
+
+- Reachable strict expansions: `2341/2432` -> `2364/2432`; legacy bypasses: `91` -> `68`.
+- `cargo fmt --check`
+- `cargo clippy -- -D warnings`
+- `yarn compile`
+- `cargo test` (one unrelated parallel feature-policy test flaked once; isolated and full reruns passed)
+- `yarn check-all`
+- `yarn check-agent-interface`
+- Respo `be8141e`: 27 tests and JS check-only passed.
+- Recollect `6c235d0`: 9 tests, JS generation, and Node runtime passed.
+- js-ffi `25869b6`: default/node/browser checks and both runtime contracts passed.

package/editing-history/20260826-0214-binding-update-macro-contracts.md

@@ -0,0 +1,14 @@
+# Binding and update macro contracts
+
+## Changes
+
+- Migrated `let-destruct`, `let-sugar`, `let[]`, `let{}`, and `loop` to phase-aware binding and body contracts.
+- Migrated `struct-with`, `swap!`, and `&doseq` with concrete struct/ref/callable inputs and struct/Unit outputs where proven.
+- Added `assert-type pair 'List` inside `let-sugar` so strict macro-body analysis retains the list evidence already guaranteed by its runtime validation.
+- Added exact Snapshot assertions for all contract fields.
+
+## Validation
+
+- Reachable strict expansions: `2364/2432` -> `2379/2432`; legacy bypasses: `68` -> `53`.
+- Full `cargo fmt`, Clippy, compile, Rust tests, `yarn check-all`, and Agent interface gates passed.
+- Latest Respo `be8141e`, Recollect `6c235d0`, and js-ffi `25869b6` regressions passed.

package/editing-history/20260826-0629-type-observability-macros.md

@@ -0,0 +1,8 @@
+# Type observability macro contracts
+
+- Migrated logging, timing, hygiene, documentation, and debug function-wrapper macros to strict phase-aware signatures.
+- Preserve expression result types for `w-log`, `wo-log`, `with-cpu-time`, and `noted` with a generic `T` contract.
+- Require callable expressions for `call-w-log` and `call-wo-log`, structural symbol/list inputs for function-definition and gensym helpers, and definition-shaped function expansions for `defn-w-log`/`defn-wo-log`.
+- Declare `:platform-read` only for macros that inspect the Calcit running mode while expanding. Runtime logging and `cpu-time` emitted into quoted code do not count as compile-time capabilities.
+- Benchmarked the full macro-contract migration against `3a7afb5e`: both release check-only medians remained about 0.15 seconds across 12 warm runs. Strict/cache-eligible expansion coverage rose from 4 to 2379 before this batch; this batch moves another 8 pure expansions to cache eligibility and classifies 5 platform-dependent expansions honestly.
+- Verified earlier, structured failures for invalid callable/list/ref macro arguments. No expansion cache exists yet, so this work provides visible diagnostics and cache prerequisites rather than a current runtime speedup.

package/editing-history/20260826-0642-type-remaining-match-macros.md

@@ -0,0 +1,7 @@
+# Remaining core match macro contracts
+
+- Migrated `case-default`, `field-match`, and `calcit.internal/&field-match-internal` to strict phase-aware macro signatures.
+- `case-default` now validates both value/default expression inputs and requires every pattern arm to be list-shaped syntax while keeping its branch-dependent output honest as `Expr<Dynamic>`.
+- `field-match` and its recursive helper now require a map expression before expansion, so invalid values fail at the public macro boundary with `E_MACRO_INPUT_EXPR_TYPE` instead of reaching generated runtime assertions.
+- Added snapshot assertions for required inputs, rest-arm syntax, pure capability sets, and expansion categories.
+- The core suite now observes 2392 pure/cache-eligible expansions, 5 explicitly platform-dependent expansions, and only 35 legacy expansions, all of which belong to test helper macros.

package/editing-history/20260826-0654-macro-log-capability.md

@@ -0,0 +1,8 @@
+# Compile-time macro log capability
+
+- Added the opt-in `:log` macro capability for compile-time `echo`, `println`, and `eprintln` calls.
+- Registered procedures remain forbidden host FFI by default; the three platform console aliases are the narrow exception and still require an explicit capability declaration.
+- Documented that quoted runtime logging stays pure while logging actually executed during expansion is observable and therefore cache-ineligible.
+- Added positive, missing-capability, and unrelated-host-procedure tests for the policy plus schema round-trip coverage for `:log`.
+- Migrated the final test helper macros: `inside-eval:`/`inside-js:` declare `:platform-read`, `add-11` declares `:log`, and the hygienic no-log helper remains pure.
+- Macro metrics now report zero legacy bypasses: 2393 pure/cache-eligible expansions and 39 explicitly capability-dependent expansions out of 2432 total. Cache hits remain zero until the planned cache implementation lands.

package/editing-history/20260826-0707-release-01345.md

@@ -0,0 +1,6 @@
+# Release 0.13.45
+
+- Publish the completed phase-aware macro contract migration and compile-time capability policy improvements.
+- Includes strict contracts across the observed core corpus, explicit `:platform-read` and `:log` effects, and zero legacy macro-signature bypasses in `calcit/test.cirru` metrics.
+- Provides the stable compiler version required for Respo's six strict macro contracts, especially `defstyle` compile-time logging.
+- Release validation is based on the merged PR gates plus latest Respo, Recollect, and js-ffi regressions run with the built compiler.

package/examples/bench_enum_match.rs

@@ -0,0 +1,41 @@
+use std::hint::black_box;
+use std::sync::Arc;
+use std::time::Instant;
+
+use calcit::calcit::{Calcit, CalcitEnumDef, CalcitList, CalcitStructDef, CalcitStructValue};
+use cirru_edn::EdnTag;
+
+const ITERATIONS: usize = 5_000_000;
+const VARIANT_COUNT: usize = 16;
+
+fn main() {
+  let fields: Vec<EdnTag> = (0..VARIANT_COUNT).map(|idx| EdnTag::new(format!("variant-{idx:02}"))).collect();
+  let values = vec![Calcit::from(CalcitList::Vector(vec![])); fields.len()];
+  let enum_def = CalcitEnumDef::from_struct(CalcitStructValue {
+    struct_ref: Arc::new(CalcitStructDef::from_fields(EdnTag::new("DispatchState"), fields)),
+    values: Arc::new(values),
+  })
+  .expect("valid benchmark enum");
+  let target = enum_def.variants().last().expect("last variant").tag.clone();
+
+  run("linear-tag-scan", || {
+    enum_def
+      .variants()
+      .iter()
+      .position(|variant| variant.tag == target)
+      .expect("target variant")
+  });
+  run("indexed-branch-slot", || enum_def.variant_index(&target).expect("target variant"));
+}
+
+fn run(label: &str, mut dispatch: impl FnMut() -> usize) {
+  let mut checksum = 0usize;
+  for _ in 0..100_000 {
+    checksum = checksum.wrapping_add(black_box(dispatch()));
+  }
+  let started = Instant::now();
+  for _ in 0..ITERATIONS {
+    checksum = checksum.wrapping_add(black_box(dispatch()));
+  }
+  println!("{label}: {:.2}ms checksum={checksum}", started.elapsed().as_secs_f64() * 1000.0);
+}

package/lib/calcit-data.d.mts

@@ -25,6 +25,10 @@ export declare let isNestedCalcitData: (x: CalcitValue) => boolean;
 export declare let tipNestedCalcitData: (x: CalcitValue) => string;
 export type CalcitFn = (...xs: CalcitValue[]) => CalcitValue;
 export declare let getStringName: (x: CalcitValue) => string;
+/** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
+export declare function compareTagNames(x: CalcitTag, y: CalcitTag): number;
+export declare function tagNamesAreCanonical(fields: CalcitTag[]): boolean;
+export declare function canonicalizeTagPairs<T>(fields: CalcitTag[], values: T[], context: string): [CalcitTag[], T[]];
 /** returns -1 when not found */
 export declare function findInFields(xs: Array<CalcitTag>, y: CalcitTag): number;
 export declare let newTag: (content: string) => CalcitTag;

package/lib/calcit-data.mjs

@@ -105,6 +105,51 @@ export let getStringName = (x) => {
     }
     throw new Error("Cannot get string as name");
 };
+/** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
+export function compareTagNames(x, y) {
+    let xIdx = 0;
+    let yIdx = 0;
+    while (xIdx < x.value.length && yIdx < y.value.length) {
+        const xCode = x.value.codePointAt(xIdx);
+        const yCode = y.value.codePointAt(yIdx);
+        if (xCode < yCode)
+            return -1;
+        if (xCode > yCode)
+            return 1;
+        xIdx += xCode > 0xffff ? 2 : 1;
+        yIdx += yCode > 0xffff ? 2 : 1;
+    }
+    if (xIdx < x.value.length)
+        return 1;
+    if (yIdx < y.value.length)
+        return -1;
+    return 0;
+}
+export function tagNamesAreCanonical(fields) {
+    for (let idx = 1; idx < fields.length; idx++) {
+        if (compareTagNames(fields[idx - 1], fields[idx]) >= 0)
+            return false;
+    }
+    return true;
+}
+export function canonicalizeTagPairs(fields, values, context) {
+    if (fields.length !== values.length) {
+        throw new Error(`${context}: fields and values length mismatch`);
+    }
+    if (tagNamesAreCanonical(fields))
+        return [fields, values];
+    const pairs = fields.map((field, idx) => [field, values[idx]]);
+    pairs.sort((a, b) => compareTagNames(a[0], b[0]));
+    for (let idx = 1; idx < pairs.length; idx++) {
+        if (pairs[idx - 1][0].value === pairs[idx][0].value) {
+            throw new Error(`${context}: duplicated field :${pairs[idx][0].value}`);
+        }
+    }
+    return [
+        pairs.map(([field]) => field),
+        pairs.map(([, value]) => value),
+    ];
+}
 /** returns -1 when not found */
 export function findInFields(xs, y) {
     let low = 0;
@@ -112,10 +157,11 @@ export function findInFields(xs, y) {
     while (low <= high) {
         const mid = Math.floor((low + high) / 2);
         const midVal = xs[mid];
-        if (midVal.idx < y.idx) {
+        const ordering = compareTagNames(midVal, y);
+        if (ordering < 0) {
             low = mid + 1;
         }
-        else if (midVal.idx > y.idx) {
+        else if (ordering > 0) {
             high = mid - 1;
         }
         else {
@@ -156,6 +202,7 @@ export let castTag = (x) => {
 };
 export var refsRegistry = new Map();
 let defaultHash_nil = valueHash("nil:");
+let defaultHash_unit = valueHash("unit:");
 let defaultHash_number = valueHash("number:");
 let defaultHash_string = valueHash("string:");
 let defaultHash_tag = valueHash("tag:");
@@ -177,9 +224,11 @@ let defaultHash_unknown = valueHash("unknown:");
 let fnHashCounter = 0;
 let jsObjectHashCounter = 0;
 export let hashFunction = (x) => {
-    if (x == null) {
+    if (x === null) {
         return defaultHash_nil;
     }
+    if (x === undefined)
+        return defaultHash_unit;
     if (typeof x === "number") {
         return mergeValueHash(defaultHash_number, x);
     }
@@ -367,9 +416,11 @@ let hashCirru = (base, x) => {
 // Dirty code to change ternary-tree behavior
 overwriteHashGenerator(hashFunction);
 export let toString = (x, escaped, disableJsDataWarning = false) => {
-    if (x == null) {
+    if (x === null) {
         return "nil";
     }
+    if (x === undefined)
+        return "&unit";
     if (typeof x === "string") {
         if (escaped) {
             // turn to visual string representation
@@ -473,9 +524,11 @@ export let to_js_data = (x, options) => {
     return to_js_data_inner(x, addColon);
 };
 let to_js_data_inner = (x, addColon) => {
-    if (x == null) {
+    if (x === null) {
         return null;
     }
+    if (x === undefined)
+        return undefined;
     if (x === true || x === false) {
         return x;
     }
@@ -560,10 +613,7 @@ export let _$n__$e_ = (x, y) => {
     if (x === y) {
         return true;
     }
-    if (x == null) {
-        if (y == null) {
-            return true;
-        }
+    if (x === null) {
         return false;
     }
     let tx = typeof x;

package/lib/calcit.procs.d.mts

@@ -18,7 +18,13 @@ export declare const calcit_package_json: {
         "test-fail": string;
         "test-snippets": string;
         "check-js-runtime": string;
+        "check-literal-paths": string;
+        "check-typed-method-rem": string;
         "bench-recur-smoke": string;
+        "bench-enum-match": string;
+        "bench-literal-paths": string;
+        "bench-typed-method-rem": string;
+        "bench-struct-index": string;
         "check-smooth": string;
         "check-all": string;
         "check-agent-interface": string;
@@ -87,7 +93,9 @@ export declare function _$n_str_$o_count(x: CalcitValue): number;
 export declare function _$n_map_$o_count(x: CalcitValue): number;
 export declare function _$n_struct_$o_count(x: CalcitValue): number;
 export declare function _$n_struct_$o_field_tag(x: CalcitValue, idx: CalcitValue): CalcitTag;
-export declare function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue, field?: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_assoc_at(x: CalcitValue, idx: CalcitValue, field: CalcitValue, value: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_with_at(x: CalcitValue, ...triples: CalcitValue[]): CalcitValue;
 export declare function _$n_set_$o_count(x: CalcitValue): number;
 export declare let _$L_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _SQUO_: (...xs: CalcitValue[]) => CalcitSliceList;
@@ -119,7 +127,7 @@ export declare let _$n_enum_$o_definition: (x: CalcitEnumValue) => CalcitEnumDef
 export declare let _$n_enum_def_$o_has_variant_$q_: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
 export declare let _$n_enum_def_$o_has_variant: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
 export declare let _$n_enum_def_$o_variant_arity: (enumPrototype: CalcitValue, variantTag: CalcitTag) => number;
-export declare let _$n_enum_$o_validate: (enumValue: CalcitValue, tag: CalcitValue) => CalcitValue;
+export declare let _$n_enum_$o_validate: (enumValue: CalcitValue, tag: CalcitValue) => void;
 export declare let _$n_struct_$o_get: (xs: CalcitValue, k: CalcitTag) => CalcitValue;
 export declare let _$n_list_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitList;
 export declare let _$n_enum_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitEnumValue;
@@ -136,9 +144,9 @@ export declare let _$n_list_$o_assoc_before: (xs: CalcitList | CalcitSliceList,
 export declare let _$n_list_$o_assoc_after: (xs: CalcitSliceList, k: number, v: CalcitValue) => CalcitList | CalcitSliceList;
 export declare let _$n_list_$o_dissoc: (xs: CalcitValue | CalcitSliceList, k: CalcitValue) => CalcitList | CalcitSliceList;
 export declare let _$n_map_$o_dissoc: (xs: CalcitValue, ...args: CalcitValue[]) => CalcitMap | CalcitSliceMap;
-export declare let reset_$x_: (a: CalcitRef, v: CalcitValue) => null;
-export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => null;
-export declare let remove_watch: (a: CalcitRef, k: CalcitTag) => null;
+export declare let reset_$x_: (a: CalcitRef, v: CalcitValue) => CalcitValue;
+export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => void;
+export declare let remove_watch: (a: CalcitRef, k: CalcitTag) => void;
 export declare let range: (n: number, m?: number, step?: number) => CalcitSliceList;
 export declare function _$n_list_$o_empty_$q_(xs: CalcitValue): boolean;
 export declare function _$n_str_$o_empty_$q_(xs: CalcitValue): boolean;
@@ -149,7 +157,7 @@ export declare let _$n_list_$o_last: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_str_$o_first: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_map_$o_destruct: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_set_$o_destruct: (xs: CalcitValue) => CalcitValue;
-export declare let timeout_call: (duration: number, f: CalcitFn) => null;
+export declare let timeout_call: (duration: number, f: CalcitFn) => void;
 export declare let _$n_list_$o_rest: (xs: CalcitValue) => CalcitList | CalcitSliceList;
 export declare let _$n_str_$o_rest: (xs: CalcitValue) => CalcitValue;
 export declare let recur: (...xs: CalcitValue[]) => CalcitRecur;
@@ -162,7 +170,7 @@ export declare let butlast: (xs: CalcitValue) => CalcitList | CalcitSliceList |
 export declare let initCrTernary: (x: string) => CalcitValue;
 export declare let _SHA__$M_: (...xs: CalcitValue[]) => CalcitValue;
 export declare let generate_id_$x_: () => string;
-export declare let _$n_display_stack: () => null;
+export declare let _$n_display_stack: () => void;
 export declare let _$n_list_$o_slice: (xs: CalcitList, from: number, to: number) => CalcitSliceList | CalcitList;
 export declare let _$n_list_$o_concat: (...lists: (CalcitList | CalcitSliceList)[]) => CalcitList | CalcitSliceList;
 export declare let _$n_list_$o_reverse: (xs: CalcitList) => CalcitList;
@@ -247,7 +255,7 @@ export declare let parse_cirru: (code: string) => CalcitCirruQuote;
 export declare let parse_cirru_list: (code: string) => CalcitList;
 export declare let parse_cirru_edn: (code: string, options: CalcitValue) => CalcitValue;
 type DataShapeNode = {
-    kind: "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" | "dynamic";
+    kind: "nil" | "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" | "dynamic";
 } | {
     kind: "optional" | "list" | "set" | "ref";
     inner: number;