@calcit/procs 0.29.0-alpha.2 → 0.29.0-alpha.23

package/lib/calcit-data.mjs

@@ -208,6 +208,7 @@ export var refsRegistry = new Map();
 let defaultHash_nil = valueHash("nil:");
 let defaultHash_unit = valueHash("unit:");
 let defaultHash_number = valueHash("number:");
+let defaultHash_nan = valueHash("number:NaN");
 let defaultHash_string = valueHash("string:");
 let defaultHash_tag = valueHash("tag:");
 let defaultHash_true = valueHash("bool:true");
@@ -237,7 +238,10 @@ export let hashFunction = (x) => {
     if (x === undefined)
         return defaultHash_unit;
     if (typeof x === "number") {
-        return mergeValueHash(defaultHash_number, x);
+        // NaN equals NaN, so it needs a hash that equals itself; `0` and `-0` share one hash
+        if (Number.isNaN(x))
+            return defaultHash_nan;
+        return mergeValueHash(defaultHash_number, x === 0 ? 0 : x);
     }
     if (typeof x === "string") {
         return mergeValueHash(defaultHash_string, x);
@@ -369,7 +373,8 @@ export let hashFunction = (x) => {
         let base = defaultHash_impl;
         base = mergeValueHash(base, hashFunction(x.name));
         if (x.origin != null) {
-            base = mergeValueHash(base, hashFunction(x.origin));
+            // Impl equality compares origin names, not trait object identities.
+            base = mergeValueHash(base, hashFunction(x.origin.name.value));
         }
         for (let idx = 0; idx < x.fields.length; idx++) {
             base = mergeValueHash(base, hashFunction(x.fields[idx]));
@@ -656,8 +661,8 @@ export let _$n__$e_ = (x, y) => {
         return false;
     }
     if (tx === "number") {
-        // already checked above
-        return false;
+        // value equality: NaN equals NaN (`0 === -0` already held above)
+        return Number.isNaN(x) && Number.isNaN(y);
     }
     if (tx === "function") {
         // method values are closures created on the fly (see invoke_method_closure),
@@ -837,7 +842,11 @@ export let _$n__$e_ = (x, y) => {
     }
     if (x instanceof CalcitEnumDef) {
         if (y instanceof CalcitEnumDef) {
-            return x.name === y.name;
+            // The prototype carries the nominal origin, variant tags and payload
+            // schemas. Comparing name methods compares one shared function object.
+            return _$n__$e_(x.prototype, y.prototype)
+                && x.impls.length === y.impls.length
+                && x.impls.every((impl, index) => _$n__$e_(impl, y.impls[index]));
         }
         return false;
     }

package/lib/calcit.procs.d.mts

@@ -31,6 +31,7 @@ export declare const calcit_package_json: {
         "check-smooth": string;
         "check-all": string;
         "check-strict-default": string;
+        "check-core-tests": string;
         "check-agent-interface": string;
         "try-all": string;
         "try-core-tests": string;
@@ -111,7 +112,7 @@ export declare let _$L_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _SQUO_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _$n__$M_: (...xs: CalcitValue[]) => CalcitSliceMap;
 export declare let defatom: (path: string, x: CalcitValue) => CalcitValue;
-export { atom } from "./js-ref.mjs";
+export { atom, ref } from "./js-ref.mjs";
 export declare let peekDefatom: (path: string) => CalcitRef;
 export declare let _$n_atom_$o_deref: (x: CalcitRef) => CalcitValue;
 export declare let _$n__ADD_: (x: number, y: number) => number;
@@ -154,7 +155,7 @@ export declare let _$n_list_$o_assoc_after: (xs: CalcitSliceList, k: number, v:
 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) => CalcitValue;
-export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => void;
+export declare let add_watch_$x_: (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;
@@ -188,7 +189,8 @@ export declare let _$n__GT_: (a: number, b: number) => boolean;
 export declare let _$n__LT_: (a: number, b: number) => boolean;
 export declare let _$n__: (a: number, b: number) => number;
 export declare let _$n__SLSH_: (a: number, b: number) => number;
-/** Truncated remainder over safe integers, matching native and WASM; the result is never `-0`. */
+/** Truncated remainder over safe integers, matching native and WASM; the result is never `-0`.
+ * Operands in the error use the native number text (`inf`, expanded exponents) so messages match native. */
 export declare let _$n_number_$o_rem: (a: number, b: number) => number;
 export declare let _$n_number_$o_fits_$q_: (value: number, target: CalcitTag) => boolean;
 export declare let round_$q_: (a: number) => boolean;
@@ -241,7 +243,7 @@ export declare let turn_symbol: (x: CalcitValue) => CalcitSymbol;
 export declare let to_lispy_string: (...args: CalcitValue[]) => string;
 /** helper function for println, js only */
 export declare let printable: (...args: CalcitValue[]) => string;
-export declare let cpu_time: () => number;
+export declare let monotonic_time_ms: () => number;
 export declare let quit_$x_: (code: number) => void;
 export declare let turn_string: (x: CalcitValue) => string;
 export declare let identical_$q_: (x: CalcitValue, y: CalcitValue) => boolean;
@@ -323,6 +325,8 @@ type DataShapeGraph = {
     fingerprint: string;
     nodes: DataShapeNode[];
 };
+/** Validate existing data without the decoder's map conversion or Option lifting. */
+export declare function validate_data_shape(input: CalcitValue, graph: DataShapeGraph): boolean;
 export declare let parse_cirru_edn_as: (code: string, graph: DataShapeGraph) => CalcitValue;
 export declare let decode_map_as: (value: CalcitValue, graph: DataShapeGraph) => CalcitValue;
 export declare let json_parse: (code: CalcitValue) => CalcitValue;
@@ -361,6 +365,7 @@ export declare function _$n_methods_of(obj: CalcitValue): CalcitSliceList;
 export declare function _$n_inspect_methods(obj: CalcitValue, note: CalcitValue): CalcitValue;
 /** Dispatch through one nominal origin; duplicate implementations never select by order. */
 export declare function _$n_trait_call(traitDef: CalcitValue, method: CalcitValue, obj: CalcitValue, ...args: CalcitValue[]): CalcitValue;
+export declare let _$n_map_$o_fold_kv: (m: CalcitValue, initial: CalcitValue, reducer: CalcitFn) => CalcitValue;
 export declare let _$n_map_$o_to_list: (m: CalcitValue) => CalcitSliceList;
 export declare let _$n_map_$o_keys: (m: CalcitValue) => CalcitSet;
 export declare let _$n_map_$o_vals: (m: CalcitValue) => CalcitSliceList;

package/lib/calcit.procs.mjs

@@ -224,7 +224,7 @@ export let _$n_trait_$o__$o_new = function (name, methods, parents) {
     const requires = parents == null ? [] : list_items(parents);
     for (const parent of requires) {
         if (!(parent instanceof CalcitTrait)) {
-            throw new Error(`trait ${toString(name, false)} 'requires expects a trait, but received: ${toString(parent, true)}`);
+            throw new Error(`trait ${toString(name, false)}: each requires entry must be a trait, but received: ${toString(parent, true)}`);
         }
     }
     const traitDef = new CalcitTrait(name, methodNames, methodTypes, requires);
@@ -508,7 +508,7 @@ export let defatom = (path, x) => {
     refsRegistry.set(path, v);
     return v;
 };
-export { atom } from "./js-ref.mjs";
+export { atom, ref } from "./js-ref.mjs";
 export let peekDefatom = (path) => {
     return refsRegistry.get(path);
 };
@@ -817,7 +817,7 @@ export let _$n_struct_$o_impl_traits = function (xs, ...traits) {
         throw new Error("&struct:impl-traits expected a struct value");
     const impls = traits.map((trait) => coerce_impl(trait, "&struct:impl-traits"));
     checkRequiredTraitImpls(xs.structRef.impls.concat(impls), "&struct:impl-traits");
-    const nextStruct = new CalcitStructDef(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(impls), xs.structRef.definitionRef);
+    const nextStruct = new CalcitStructDef(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(impls), xs.structRef.definitionRef, xs.structRef.fieldValidators);
     return new CalcitStructValue(xs.name, xs.fields, xs.values, nextStruct);
 };
 export let _$n_struct_def_$o_impl_traits = function (xs, ...traits) {
@@ -828,7 +828,7 @@ export let _$n_struct_def_$o_impl_traits = function (xs, ...traits) {
     const addedImpls = traits.map((trait) => coerce_impl(trait, "&struct-def:impl-traits"));
     const baseImpls = xs.impls ?? [];
     checkRequiredTraitImpls(baseImpls.concat(addedImpls), "&struct-def:impl-traits");
-    return new CalcitStructDef(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls), xs.definitionRef);
+    return new CalcitStructDef(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls), xs.definitionRef, xs.fieldValidators);
 };
 export let _$n_enum_def_$o_impl_traits = function (xs, ...traits) {
     if (traits.length < 1)
@@ -920,7 +920,7 @@ export let reset_$x_ = (a, v) => {
     });
     return v;
 };
-export let add_watch = (a, k, f) => {
+export let add_watch_$x_ = (a, k, f) => {
     if (!(a instanceof CalcitRef)) {
         throw new Error("Expected ref for add-watch!");
     }
@@ -1200,10 +1200,11 @@ export let _$n__ = (a, b) => {
 export let _$n__SLSH_ = (a, b) => {
     return a / b;
 };
-/** Truncated remainder over safe integers, matching native and WASM; the result is never `-0`. */
+/** Truncated remainder over safe integers, matching native and WASM; the result is never `-0`.
+ * Operands in the error use the native number text (`inf`, expanded exponents) so messages match native. */
 export let _$n_number_$o_rem = (a, b) => {
     if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b)) {
-        throw new Error(`&number:rem requires safe integers, but received: ${toString(a, false)} ${toString(b, false)}`);
+        throw new Error(`&number:rem requires safe integers, but received: ${format_calcit_number(a)} ${format_calcit_number(b)}`);
     }
     if (b === 0) {
         throw new Error("&number:rem divisor must not be zero");
@@ -1418,7 +1419,12 @@ export let _$n_str_$o_replace = (x, y, z) => {
     return x.replace(new RegExp(literalPattern, "gu"), () => z);
 };
 export let split = (xs, x) => {
-    return new CalcitSliceList(xs.split(x));
+    // An empty delimiter splits by code point, matching native for astral characters.
+    if (x === "") {
+        return new CalcitSliceList(Array.from(xs));
+    }
+    // Drop empty pieces to match native and WASM: `split | |,` is an empty list.
+    return new CalcitSliceList(xs.split(x).filter((piece) => piece !== ""));
 };
 export let split_lines = (xs) => {
     return new CalcitSliceList(xs.split("\n"));
@@ -1655,8 +1661,8 @@ export let to_lispy_string = (...args) => {
 export let printable = (...args) => {
     return args.map((x) => toString(x, false)).join(" ");
 };
-// time from app start
-export let cpu_time = () => {
+// monotonic milliseconds since app start
+export let monotonic_time_ms = () => {
     if (inNodeJs) {
         // uptime returns in seconds
         return process.uptime() * 1000;
@@ -1941,6 +1947,64 @@ export let parse_cirru_edn = (code, options) => {
         throw new Error(`Expected EDN in a single node, got ${nodes.length}`);
     }
 };
+/** Validate existing data without the decoder's map conversion or Option lifting. */
+export function validate_data_shape(input, graph) {
+    if (graph.version !== 3)
+        throw new Error(`validate-data-shape expected ABI version 3, got ${graph.version}`);
+    const sameNominal = (actual, expected) => actual === expected || (actual != null && expected != null && expected.definitionRef != null &&
+        actual.definitionRef === expected.definitionRef && actual.name.value === expected.name.value &&
+        actual.fields.length === expected.fields.length && actual.fields.every((field, idx) => field.value === expected.fields[idx].value && _$n__$e_(actual.fieldTypes[idx], expected.fieldTypes[idx])));
+    const check = (value, nodeId, depth) => {
+        if (depth > 1024)
+            return false;
+        const node = graph.nodes[nodeId];
+        if (node == null)
+            return false;
+        switch (node.kind) {
+            case "dynamic": return true;
+            case "nil": return value === null;
+            case "unit": return value === undefined;
+            case "bool": return typeof value === "boolean";
+            case "number": return typeof value === "number";
+            case "numeric": return typeof value === "number" && _$n_number_$o_fits_$q_(value, newTag(node.target));
+            case "string": return typeof value === "string";
+            case "symbol": return value instanceof CalcitSymbol;
+            case "tag": return value instanceof CalcitTag;
+            case "buffer": return value instanceof Uint8Array;
+            case "cirru-quote": return value instanceof CalcitCirruQuote;
+            case "optional": return value === null || check(value, node.inner, depth + 1);
+            case "list": {
+                if (!(value instanceof CalcitList || value instanceof CalcitSliceList))
+                    return false;
+                for (const item of value.items())
+                    if (!check(item, node.inner, depth + 1))
+                        return false;
+                return true;
+            }
+            case "set": return value instanceof CalcitSet && value.values().every(item => check(item, node.inner, depth + 1));
+            case "map": return (value instanceof CalcitMap || value instanceof CalcitSliceMap) && value.pairs().every(([key, item]) => check(key, node.key, depth + 1) && check(item, node.value, depth + 1));
+            case "ref": return value instanceof CalcitRef && check(value.value, node.inner, depth + 1);
+            case "struct": return value instanceof CalcitStructValue && sameNominal(value.structRef, node.nominal) &&
+                value.values.length === node.fields.length && node.fields.every(([name, child], idx) => value.fields[idx]?.value === name && check(value.values[idx], child, depth + 1));
+            case "map-option":
+            case "enum": {
+                if (!(value instanceof CalcitEnumValue) || value.enumPrototype == null ||
+                    !sameNominal(value.enumPrototype.prototype.structRef, node.nominal.prototype.structRef) ||
+                    !_$n__$e_(value.enumPrototype.prototype, node.nominal.prototype) || !(value.tag instanceof CalcitTag))
+                    return false;
+                if (node.kind === "map-option") {
+                    return value.tag.value === "none" ? value.extra.length === 0 : value.tag.value === "some" &&
+                        value.extra.length === 1 && check(value.extra[0], node.inner, depth + 1);
+                }
+                const tag = value.tag.value;
+                const variant = node.variants.find(candidate => candidate.tag === tag);
+                return variant != null && value.extra.length === variant.payload.length &&
+                    variant.payload.every((child, idx) => check(value.extra[idx], child, depth + 1));
+            }
+        }
+    };
+    return check(input, graph.root, 0);
+}
 const typed_edn_kind = (value) => {
     if (value === null)
         return "nil";
@@ -2808,6 +2872,19 @@ export function _$n_trait_call(traitDef, method, obj, ...args) {
     }
     throw new Error(`&trait-call: cannot find impl for trait ${traitDef.name.toString()} on ${toString(obj, true)}. Hint: use defimpl to create impls tagged by trait.`);
 }
+export let _$n_map_$o_fold_kv = (m, initial, reducer) => {
+    if (!(m instanceof CalcitMap || m instanceof CalcitSliceMap)) {
+        throw new Error("&map:fold-kv expected a Map");
+    }
+    if (typeof reducer !== "function") {
+        throw new Error("&map:fold-kv expected a callback function");
+    }
+    let accumulator = initial;
+    for (const [key, value] of m.pairs()) {
+        accumulator = reducer(accumulator, key, value);
+    }
+    return accumulator;
+};
 export let _$n_map_$o_to_list = (m) => {
     if (m instanceof CalcitMap || m instanceof CalcitSliceMap) {
         let ys = [];

package/lib/js-primes.d.mts

@@ -12,4 +12,6 @@ import { CalcitCirruQuote } from "./js-cirru.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
 export type CalcitValue = string | number | boolean | CalcitMap | CalcitSliceMap | CalcitList | CalcitSliceList | CalcitSet | CalcitTag | CalcitSymbol | CalcitRef | CalcitEnumValue | CalcitFn | CalcitRecur | CalcitStructValue | CalcitImpl | CalcitTrait | CalcitStructDef | CalcitEnumDef | CalcitCirruQuote | Uint8Array | undefined | null;
 export declare let isLiteral: (x: CalcitValue) => boolean;
+/** total order over numbers: `-0` equals `0`, NaN equals NaN and sorts after every number */
+export declare let compareNumbers: (x: number, y: number) => number;
 export declare let _$n_compare: (a: CalcitValue, b: CalcitValue) => number;

package/lib/js-primes.mjs

@@ -101,6 +101,14 @@ let rawCompare = (x, y) => {
         return 0;
     }
 };
+/** total order over numbers: `-0` equals `0`, NaN equals NaN and sorts after every number */
+export let compareNumbers = (x, y) => {
+    if (x < y)
+        return -1;
+    if (x > y)
+        return 1;
+    return (Number.isNaN(x) ? 1 : 0) - (Number.isNaN(y) ? 1 : 0);
+};
 /** lexicographic order over two sequences of values, a shorter prefix sorts first (same as Rust `Vec::cmp`) */
 let compareSequences = (xs, ys) => {
     let n = Math.min(xs.length, ys.length);
@@ -112,6 +120,18 @@ let compareSequences = (xs, ys) => {
     return rawCompare(xs.length, ys.length);
 };
 let listToArray = (x) => Array.from(x.items());
+// Plain functions compare by identity. IDs are process-local, never serialized,
+// and kept weakly so ordering does not retain closures or mutate frozen hosts.
+const functionOrderIds = new WeakMap();
+let nextFunctionOrderId = 0;
+const functionOrderId = (fn) => {
+    let id = functionOrderIds.get(fn);
+    if (id === undefined) {
+        id = ++nextFunctionOrderId;
+        functionOrderIds.set(fn, id);
+    }
+    return id;
+};
 export let _$n_compare = (a, b) => {
     if (a === b)
         return 0;
@@ -125,7 +145,7 @@ export let _$n_compare = (a, b) => {
             case PseudoTypeIndex.bool:
                 return rawCompare(a, b);
             case PseudoTypeIndex.number:
-                return rawCompare(a, b);
+                return compareNumbers(a, b);
             case PseudoTypeIndex.tag:
                 return rawCompare(a.value, b.value);
             case PseudoTypeIndex.symbol:
@@ -134,6 +154,36 @@ export let _$n_compare = (a, b) => {
                 return rawCompare(a, b);
             case PseudoTypeIndex.ref:
                 return rawCompare(a.path, b.path);
+            case PseudoTypeIndex.fn: {
+                const left = a;
+                const right = b;
+                // Method closures use name equality, unlike ordinary function values.
+                if (left.__calcitMethodName != null || right.__calcitMethodName != null) {
+                    if (left.__calcitMethodName == null)
+                        return -1;
+                    if (right.__calcitMethodName == null)
+                        return 1;
+                    return compareUnicodeStrings(left.__calcitMethodName, right.__calcitMethodName);
+                }
+                return rawCompare(functionOrderId(left), functionOrderId(right));
+            }
+            case PseudoTypeIndex.impl: {
+                const left = a;
+                const right = b;
+                const nameOrder = compareUnicodeStrings(left.name.value, right.name.value);
+                if (nameOrder !== 0)
+                    return nameOrder;
+                if (left.origin == null && right.origin != null)
+                    return -1;
+                if (left.origin != null && right.origin == null)
+                    return 1;
+                if (left.origin != null && right.origin != null) {
+                    const originOrder = compareUnicodeStrings(left.origin.name.value, right.origin.name.value);
+                    if (originOrder !== 0)
+                        return originOrder;
+                }
+                return compareSequences(left.fields, right.fields) || compareSequences(left.values, right.values);
+            }
             case PseudoTypeIndex.struct_value: {
                 const left = a;
                 const right = b;
@@ -176,6 +226,43 @@ export let _$n_compare = (a, b) => {
                     return tagOrder;
                 return compareSequences(left.extra, right.extra);
             }
+            case PseudoTypeIndex.enum_def: {
+                const left = a;
+                const right = b;
+                const leftRef = left.prototype.structRef.definitionRef;
+                const rightRef = right.prototype.structRef.definitionRef;
+                if (leftRef !== rightRef) {
+                    if (leftRef == null)
+                        return -1;
+                    if (rightRef == null)
+                        return 1;
+                    return compareUnicodeStrings(leftRef, rightRef);
+                }
+                const nameOrder = compareUnicodeStrings(left.name(), right.name());
+                if (nameOrder !== 0)
+                    return nameOrder;
+                const variantCountOrder = rawCompare(left.prototype.fields.length, right.prototype.fields.length);
+                if (variantCountOrder !== 0)
+                    return variantCountOrder;
+                for (let index = 0; index < left.prototype.fields.length; index++) {
+                    const tagOrder = _$n_compare(left.prototype.fields[index], right.prototype.fields[index]);
+                    if (tagOrder !== 0)
+                        return tagOrder;
+                    const leftPayload = left.prototype.values[index];
+                    const rightPayload = right.prototype.values[index];
+                    // Native orders variant payloads by arity before comparing types.
+                    if ((leftPayload instanceof CalcitList || leftPayload instanceof CalcitSliceList)
+                        && (rightPayload instanceof CalcitList || rightPayload instanceof CalcitSliceList)) {
+                        const arityOrder = rawCompare(leftPayload.len(), rightPayload.len());
+                        if (arityOrder !== 0)
+                            return arityOrder;
+                    }
+                    const payloadOrder = _$n_compare(leftPayload, rightPayload);
+                    if (payloadOrder !== 0)
+                        return payloadOrder;
+                }
+                return rawCompare(left.impls.length, right.impls.length) || compareSequences(left.impls, right.impls);
+            }
             case PseudoTypeIndex.set: {
                 // like native: smaller sets first, then the sorted elements
                 const left = Array.from(a.values());

package/lib/js-ref.d.mts

@@ -9,4 +9,7 @@ export declare class CalcitRef {
     constructor(x: CalcitValue, path: string);
     toString(): string;
 }
+/** Creates a local `Ref<T>`; generated code calls this for both `ref` and the compatibility spelling `atom`. */
+export declare let ref: (x: CalcitValue) => CalcitValue;
+/** Compatibility export for JavaScript callers written before `ref`; it is the same function. */
 export declare let atom: (x: CalcitValue) => CalcitValue;

package/lib/js-ref.mjs

@@ -10,8 +10,11 @@ export class CalcitRef {
     }
 }
 var atomCounter = 0;
-export let atom = (x) => {
+/** Creates a local `Ref<T>`; generated code calls this for both `ref` and the compatibility spelling `atom`. */
+export let ref = (x) => {
     atomCounter = atomCounter + 1;
     let v = new CalcitRef(x, `atom-${atomCounter}`);
     return v;
 };
+/** Compatibility export for JavaScript callers written before `ref`; it is the same function. */
+export let atom = ref;

package/lib/js-struct-def.d.mts

@@ -1,6 +1,7 @@
 import { CalcitTag } from "./calcit-data.mjs";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
+export type FieldValidator = ((value: CalcitValue, requireEvidence?: boolean) => boolean) | null;
 export declare class CalcitStructDef {
     name: CalcitTag;
     fields: CalcitTag[];
@@ -8,9 +9,10 @@ export declare class CalcitStructDef {
     impls: CalcitImpl[];
     cachedHash: number;
     readonly definitionRef: string | null;
-    constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls?: CalcitImpl[], definitionRef?: string | null);
+    readonly fieldValidators: FieldValidator[] | null;
+    constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls?: CalcitImpl[], definitionRef?: string | null, fieldValidators?: FieldValidator[] | null);
     withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStructDef;
     toString(disableJsDataWarning?: boolean): string;
 }
-/** Match native definition binding without replacing an alias's existing identity. */
-export declare function bind_struct_definition(value: CalcitValue, definitionRef: string): CalcitValue;
+/** Bind nominal definitions like native, preserving an alias's existing identity. */
+export declare function bind_struct_definition(value: CalcitValue, definitionRef: string, fieldValidators?: FieldValidator[] | null): CalcitValue;

package/lib/js-struct-def.mjs

@@ -1,7 +1,9 @@
 import { canonicalizeTagPairs, toString } from "./calcit-data.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
+import { CalcitStructValue } from "./js-struct-value.mjs";
 export class CalcitStructDef {
-    constructor(name, fields, fieldTypes, impls = [], definitionRef = null) {
+    constructor(name, fields, fieldTypes, impls = [], definitionRef = null, fieldValidators = null) {
         const [canonicalFields, canonicalTypes] = canonicalizeTagPairs(fields, fieldTypes, "CalcitStructDef");
         this.name = name;
         this.fields = canonicalFields;
@@ -9,13 +11,14 @@ export class CalcitStructDef {
         this.impls = impls ?? [];
         this.cachedHash = null;
         this.definitionRef = definitionRef;
+        this.fieldValidators = fieldValidators == null ? null : canonicalizeTagPairs(fields, fieldValidators, "CalcitStructDef validators")[1];
     }
     withImpls(impls) {
         if (impls instanceof CalcitImpl) {
-            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, [impls], this.definitionRef);
+            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, [impls], this.definitionRef, this.fieldValidators);
         }
         else if (Array.isArray(impls)) {
-            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, impls, this.definitionRef);
+            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, impls, this.definitionRef, this.fieldValidators);
         }
         throw new Error("Expected an impl as implementation");
     }
@@ -33,10 +36,15 @@ export class CalcitStructDef {
         return parts.join("");
     }
 }
-/** Match native definition binding without replacing an alias's existing identity. */
-export function bind_struct_definition(value, definitionRef) {
+/** Bind nominal definitions like native, preserving an alias's existing identity. */
+export function bind_struct_definition(value, definitionRef, fieldValidators = null) {
     if (value instanceof CalcitStructDef && value.definitionRef == null) {
-        return new CalcitStructDef(value.name, value.fields, value.fieldTypes, value.impls, definitionRef);
+        return new CalcitStructDef(value.name, value.fields, value.fieldTypes, value.impls, definitionRef, fieldValidators);
+    }
+    if (value instanceof CalcitEnumDef && value.prototype.structRef.definitionRef == null) {
+        const prototype = value.prototype;
+        const structRef = bind_struct_definition(prototype.structRef, definitionRef);
+        return new CalcitEnumDef(new CalcitStructValue(prototype.name, prototype.fields, prototype.values, structRef));
     }
     return value;
 }

package/lib/js-struct-value.mjs

@@ -1,7 +1,17 @@
 import { CalcitImpl } from "./js-impl.mjs";
-import { newTag, castTag, toString, getStringName, findInFields, compareTagNames, canonicalizeTagPairs, } from "./calcit-data.mjs";
+import { newTag, castTag, toString, CalcitTag, CalcitSymbol, getStringName, findInFields, compareTagNames, canonicalizeTagPairs, } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitStructDef } from "./js-struct-def.mjs";
+import { valueMatchesTypeForm } from "./js-type-form.mjs";
+/// Field writes check the declared field type, like the native runtime.
+let assertFieldValue = (structRef, idx, value, operation, requireEvidence = false) => {
+    const fieldType = structRef?.fieldTypes?.[idx];
+    const validator = structRef?.fieldValidators?.[idx];
+    if (validator != null ? !validator(value, requireEvidence)
+        : fieldType != null && !valueMatchesTypeForm(value, fieldType, requireEvidence)) {
+        throw new Error(`${operation} field :${structRef.fields[idx].value} expects type ${toString(fieldType, true)}, but received ${toString(value, true)}`);
+    }
+};
 export class CalcitStructValue {
     constructor(name, fields, values, structRef) {
         this.name = name;
@@ -40,16 +50,14 @@ export class CalcitStructValue {
         }
     }
     assoc(k, v) {
-        let values = new Array(this.fields.length);
-        let k_id = castTag(k);
-        for (let idx = 0; idx < this.fields.length; idx++) {
-            if (this.fields[idx] === k_id) {
-                values[idx] = v;
-            }
-            else {
-                values[idx] = this.values[idx];
-            }
+        const field = castTag(k);
+        const idx = findInFields(this.fields, field);
+        if (idx < 0) {
+            throw new Error(`&struct:assoc invalid field ${field.toString()} for struct '${this.name.value}'`);
         }
+        assertFieldValue(this.structRef, idx, v, "&struct:assoc", true);
+        const values = this.values.slice();
+        values[idx] = v;
         return new CalcitStructValue(this.name, this.fields, values, this.structRef);
     }
     nthAt(index, field) {
@@ -60,6 +68,7 @@ export class CalcitStructValue {
     assocAt(index, field, value) {
         const idx = checkedStructIndex(index, "&struct:assoc-at");
         this.assertFieldAt(idx, field, "&struct:assoc-at");
+        assertFieldValue(this.structRef, idx, value, "&struct:assoc-at");
         const values = this.values.slice();
         values[idx] = value;
         return new CalcitStructValue(this.name, this.fields, values, this.structRef);
@@ -72,6 +81,7 @@ export class CalcitStructValue {
         for (let base = 0; base < triples.length; base += 3) {
             const idx = checkedStructIndex(triples[base], "&struct:with-at");
             this.assertFieldAt(idx, triples[base + 1], "&struct:with-at");
+            assertFieldValue(this.structRef, idx, triples[base + 2], "&struct:with-at");
             values[idx] = triples[base + 2];
         }
         return new CalcitStructValue(this.name, this.fields, values, this.structRef);
@@ -116,7 +126,7 @@ export class CalcitStructValue {
         else {
             throw new Error("Expected an impl or array of impls");
         }
-        let nextStruct = new CalcitStructDef(this.name, this.fields, this.structRef.fieldTypes, this.structRef.impls.concat(nextImpls), this.structRef.definitionRef);
+        let nextStruct = new CalcitStructDef(this.name, this.fields, this.structRef.fieldTypes, this.structRef.impls.concat(nextImpls), this.structRef.definitionRef, this.structRef.fieldValidators);
         return new CalcitStructValue(this.name, this.fields, this.values, nextStruct);
     }
 }
@@ -181,45 +191,38 @@ export let fieldsEqual = (xs, ys) => {
     }
     return true;
 };
-export let _$n__PCT__$M_ = (proto, ...xs) => {
-    let recordProto;
-    if (proto instanceof CalcitStructValue) {
-        recordProto = proto;
+// Share complete construction without spreading map contents into call arguments.
+const constructStruct = (proto, xs) => {
+    if (!(proto instanceof CalcitStructDef)) {
+        throw new Error("Expected prototype to be a StructDef");
     }
-    else if (proto instanceof CalcitStructDef) {
-        recordProto = new CalcitStructValue(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
+    if (xs.length % 2 !== 0) {
+        throw new Error("Expected even number of key/value");
     }
-    else {
-        throw new Error("Expected prototype to be a StructDef");
+    if (xs.length !== proto.fields.length * 2) {
+        throw new Error("fields size does not match");
     }
-    {
-        if (xs.length % 2 !== 0) {
-            throw new Error("Expected even number of key/value");
+    const values = new Array(proto.fields.length);
+    const seen = new Set();
+    for (let i = 0; i < xs.length; i += 2) {
+        const key = xs[i];
+        if (!(key instanceof CalcitTag) && !(key instanceof CalcitSymbol) && typeof key !== "string") {
+            throw new Error("&%{} requires field in string/tag/symbol");
         }
-        if (xs.length !== recordProto.fields.length * 2) {
-            throw new Error("fields size does not match");
+        const idx = findInFields(proto.fields, castTag(key));
+        if (idx < 0) {
+            throw new Error("invalid field name for this struct");
         }
-        let values = new Array(recordProto.fields.length);
-        for (let i = 0; i < recordProto.fields.length; i++) {
-            let idx = -1;
-            let k = recordProto.fields[i];
-            for (let j = 0; j < recordProto.fields.length; j++) {
-                if (k === castTag(xs[j * 2])) {
-                    idx = j;
-                    break;
-                }
-            }
-            if (idx < 0) {
-                throw new Error("invalid field name for this struct");
-            }
-            if (values[i] != null) {
-                throw new Error("struct field already has value, probably duplicated key");
-            }
-            values[i] = xs[idx * 2 + 1];
+        if (seen.has(idx)) {
+            throw new Error("struct field already has value, probably duplicated key");
         }
-        return new CalcitStructValue(recordProto.name, recordProto.fields, values, recordProto.structRef);
+        seen.add(idx);
+        assertFieldValue(proto, idx, xs[i + 1], "&%{}");
+        values[idx] = xs[i + 1];
     }
+    return new CalcitStructValue(proto.name, proto.fields, values, proto);
 };
+export let _$n__PCT__$M_ = (proto, ...xs) => constructStruct(proto, xs);
 /// update record with new values
 export let _$n_struct_$o_with = (proto, ...xs) => {
     if (proto instanceof CalcitStructValue) {
@@ -234,6 +237,7 @@ export let _$n_struct_$o_with = (proto, ...xs) => {
             if (idx < 0) {
                 throw new Error(`Cannot find field ${k} among ${proto.fields}`);
             }
+            assertFieldValue(proto.structRef, idx, v, "&struct:with", true);
             values[idx] = v;
         }
         return new CalcitStructValue(proto.name, proto.fields, values, proto.structRef);
@@ -261,57 +265,20 @@ export let _$n_struct_$o_definition = (x) => {
     }
 };
 export let _$n_struct_$o_from_map = (proto, data) => {
-    let recordProto;
-    if (proto instanceof CalcitStructDef) {
-        recordProto = new CalcitStructValue(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
-    }
-    else {
+    if (!(proto instanceof CalcitStructDef)) {
         throw new Error("Expected prototype to be struct");
     }
-    if (data instanceof CalcitStructValue) {
-        if (fieldsEqual(recordProto.fields, data.fields)) {
-            return new CalcitStructValue(recordProto.name, recordProto.fields, data.values, recordProto.structRef);
-        }
-        else {
-            let values = [];
-            for (let i = 0; i < recordProto.fields.length; i++) {
-                let field = recordProto.fields[i];
-                let idx = findInFields(data.fields, field);
-                if (idx < 0) {
-                    throw new Error(`Cannot find field ${field} among ${data.fields}`);
-                }
-                values.push(data.values[idx]);
-            }
-            return new CalcitStructValue(recordProto.name, recordProto.fields, values, recordProto.structRef);
-        }
+    if (!(data instanceof CalcitMap) && !(data instanceof CalcitSliceMap)) {
+        throw new Error("&struct:from-map requires a Map");
     }
-    else if (data instanceof CalcitMap || data instanceof CalcitSliceMap) {
-        let pairs_buffer = [];
-        let pairs = data.pairs();
-        for (let i = 0; i < pairs.length; i++) {
-            let k = pairs[i][0];
-            let v = pairs[i][1];
-            pairs_buffer.push([castTag(k), v]);
+    const fields = [];
+    for (const [key, value] of data.pairs()) {
+        if (!(key instanceof CalcitTag) && typeof key !== "string") {
+            throw new Error("&struct:from-map requires field in string/tag");
         }
-        // mutable sort
-        pairs_buffer.sort((pair1, pair2) => pair1[0].cmp(pair2[0]));
-        let values = [];
-        outerLoop: for (let i = 0; i < recordProto.fields.length; i++) {
-            let field = recordProto.fields[i];
-            for (let idx = 0; idx < pairs_buffer.length; idx++) {
-                let pair = pairs_buffer[idx];
-                if (pair[0] === field) {
-                    values.push(pair[1]);
-                    continue outerLoop; // dirty code for performance
-                }
-            }
-            throw new Error(`Cannot find field ${field} among ${pairs_buffer}`);
-        }
-        return new CalcitStructValue(recordProto.name, recordProto.fields, values, recordProto.structRef);
-    }
-    else {
-        throw new Error("Expected a struct value or data for making a struct");
+        fields.push(key, value);
     }
+    return constructStruct(proto, fields);
 };
 export let _$n_struct_$o_to_map = (x) => {
     if (x instanceof CalcitStructValue) {

package/lib/js-type-form.d.mts

@@ -0,0 +1,2 @@
+import { CalcitValue } from "./js-primes.mjs";
+export declare let valueMatchesTypeForm: (value: CalcitValue, form: CalcitValue, requireEvidence?: boolean) => boolean;

package/lib/js-type-form.mjs

@@ -0,0 +1,188 @@
+import { CalcitSymbol, CalcitTag } from "./calcit-data.mjs";
+import { CalcitList, CalcitSliceList } from "./js-list.mjs";
+import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
+import { CalcitSet } from "./js-set.mjs";
+import { CalcitRef } from "./js-ref.mjs";
+import { CalcitEnumValue } from "./js-enum-value.mjs";
+import { CalcitCirruQuote } from "./js-cirru.mjs";
+/// Shallow runtime check of a value against a struct field type form, matching
+/// the native `value_matches_type_annotation`: container kinds are checked,
+/// members are not. Names that cannot be resolved here (aliases, traits, type
+/// variables) stay permissive only for the legacy, statically checked path.
+/// Dynamic writes require evidence: deep contracts use generated validators,
+/// while this fallback accepts only completely checkable scalar/open forms.
+export let valueMatchesTypeForm = (value, form, requireEvidence = false) => matchTypeForm(value, form, requireEvidence) === true;
+// null means that the contract cannot be checked here, not a mismatched value.
+// Nullable absence proves its own branch; present payloads still require
+// evidence for the inner contract.
+let matchTypeForm = (value, form, requireEvidence) => {
+    if (form instanceof CalcitSliceList || form instanceof CalcitList) {
+        const items = form.toArray();
+        const head = items[0];
+        if (head instanceof CalcitSymbol && head.value === "quote") {
+            return matchTypeForm(value, items[1], requireEvidence);
+        }
+        if (head instanceof CalcitSymbol && head.value === "::") {
+            const name = typeFormName(items[1]);
+            // Nil is `null` here; `undefined` is Unit. Only the JS host boundary
+            // type also admits `undefined`.
+            if (name === "Optional") {
+                return value === null ? true : matchTypeForm(value, items[2], requireEvidence);
+            }
+            if (name === "JsNullish") {
+                return value == null ? true : matchTypeForm(value, items[2], requireEvidence);
+            }
+            if (name === "Fn" && requireEvidence)
+                return null;
+            return name == null ? (requireEvidence ? null : true) : valueMatchesTypeName(value, name, requireEvidence);
+        }
+        return requireEvidence ? null : true;
+    }
+    const name = typeFormName(form);
+    return name == null ? (requireEvidence ? null : true) : valueMatchesTypeName(value, name, requireEvidence);
+};
+let typeFormName = (form) => {
+    if (form instanceof CalcitSymbol)
+        return form.value;
+    if (form instanceof CalcitTag)
+        return form.value;
+    if (form instanceof CalcitSliceList || form instanceof CalcitList) {
+        const items = form.toArray();
+        if (items[0] instanceof CalcitSymbol && items[0].value === "quote")
+            return typeFormName(items[1]);
+    }
+    return null;
+};
+/// Numeric refinements check range and integrality like the native `CalcitNumericRefinement::accepts`.
+let isIntegerIn = (value, min, max) => typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+let isList = (value) => value instanceof CalcitList || value instanceof CalcitSliceList;
+let isMap = (value) => value instanceof CalcitMap || value instanceof CalcitSliceMap;
+let valueMatchesTypeName = (value, rawName, requireEvidence) => {
+    const name = rawName.startsWith("calcit.core/") ? rawName.slice("calcit.core/".length) : rawName;
+    switch (name) {
+        case "Dynamic":
+        case "dynamic":
+        case "any":
+        case "JsObject":
+            return true;
+        case "Number":
+        case "number":
+        case "Float64":
+        case "float64":
+            return typeof value === "number";
+        case "Float32":
+        case "float32":
+            return typeof value === "number" && Math.fround(value) === value;
+        case "Int8":
+        case "int8":
+            return isIntegerIn(value, -128, 127);
+        case "UInt8":
+        case "uint8":
+            return isIntegerIn(value, 0, 255);
+        case "Int16":
+        case "int16":
+            return isIntegerIn(value, -32768, 32767);
+        case "UInt16":
+        case "uint16":
+            return isIntegerIn(value, 0, 65535);
+        case "Int32":
+        case "int32":
+            return isIntegerIn(value, -2147483648, 2147483647);
+        case "UInt32":
+        case "uint32":
+            return isIntegerIn(value, 0, 4294967295);
+        case "Int64":
+        case "int64":
+            return isIntegerIn(value, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        case "UInt64":
+        case "uint64":
+            return isIntegerIn(value, 0, Number.MAX_SAFE_INTEGER);
+        case "String":
+        case "string":
+            return typeof value === "string";
+        case "Bool":
+        case "bool":
+            return typeof value === "boolean";
+        case "Tag":
+        case "tag":
+            return value instanceof CalcitTag;
+        case "Symbol":
+        case "symbol":
+            return value instanceof CalcitSymbol;
+        case "Nil":
+        case "nil":
+            return value === null;
+        case "Unit":
+        case "unit":
+            return value === undefined;
+        case "Never":
+            return false;
+        case "Buffer":
+        case "buffer":
+            return value instanceof Uint8Array;
+        case "CirruQuote":
+        case "cirru-quote":
+            return value instanceof CalcitCirruQuote;
+        case "List":
+        case "list":
+            return requireEvidence ? null : isList(value);
+        case "Map":
+        case "map":
+            return requireEvidence ? null : isMap(value);
+        case "Set":
+        case "set":
+            return requireEvidence ? null : value instanceof CalcitSet;
+        case "Ref":
+        case "ref":
+            return requireEvidence ? null : value instanceof CalcitRef;
+        case "Fn":
+        case "fn":
+            return typeof value === "function";
+        case "Struct":
+        case "struct":
+        case "record":
+            return requireEvidence ? null : isStructValue(value);
+        case "Enum":
+        case "enum":
+        case "tuple":
+            return requireEvidence ? null : value instanceof CalcitEnumValue;
+    }
+    // Deep/nominal contracts must use the compiler's resolved validator. A
+    // short-name match or an erased generic cannot establish runtime evidence.
+    if (requireEvidence)
+        return null;
+    // Core Struct and Enum definitions (bare names resolve to them through the
+    // implicit core import) are known here, so a reference to one admits only
+    // values of that definition, as the native matcher does.
+    if (CORE_NOMINAL_DEFS.has(name)) {
+        if (isStructValue(value))
+            return value.structRef.definitionRef === `calcit.core/${name}`;
+        return value instanceof CalcitEnumValue && value.enumPrototype?.prototype.structRef.definitionRef === `calcit.core/${name}`;
+    }
+    // Other names may be type variables, aliases or traits that cannot be
+    // resolved here. A qualified reference is checked against the value's own
+    // Struct or Enum name; other values are left to the static checker like
+    // unresolved forms.
+    const shortName = name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name;
+    if (isStructValue(value))
+        return value.name.value === shortName || !name.includes("/");
+    if (value instanceof CalcitEnumValue && value.enumPrototype != null) {
+        return value.enumPrototype.name() === shortName || !name.includes("/");
+    }
+    return true;
+};
+/// Struct and Enum definitions of `calcit.core` usable as field types.
+const CORE_NOMINAL_DEFS = new Set([
+    "Option",
+    "Result",
+    "Data",
+    "ListDestruct",
+    "MapDestruct",
+    "SetDestruct",
+    "StringDestruct",
+    "MapEntry",
+    "RuntimeMapMeta",
+    "RuntimeMapResponse",
+]);
+// Duck-typed to avoid a module cycle with js-struct-value.
+let isStructValue = (value) => value != null && typeof value === "object" && "structRef" in value && "fields" in value;

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.29.0-alpha.2",
+    "version": "0.29.0-alpha.23",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",
@@ -21,7 +21,7 @@
         "test-rs": "cargo test -q",
         "test-fail": "cargo test -q --bin calcit type_fail_",
         "test-snippets": "cargo test -q snippets::tests",
-        "check-js-runtime": "node scripts/check-js-runtime-identity.mjs && cargo build --bin calcit && node scripts/check-string-unicode.mjs && node scripts/check-numeric-predicate.mjs && node scripts/check-predicate-method-names.mjs && node scripts/check-map-add-trait-boundary.mjs && node scripts/check-typed-string-conversions.mjs && node scripts/check-identity-conversion-fix.mjs && node scripts/check-nil-predicate.mjs && node scripts/check-monotonic-clock-js.mjs && node scripts/check-helper-inference.mjs",
+        "check-js-runtime": "node scripts/check-js-runtime-identity.mjs && cargo build --bin calcit && node scripts/check-string-unicode.mjs && node scripts/check-map-add-trait-boundary.mjs && node scripts/check-typed-string-conversions.mjs && node scripts/check-identity-conversion-fix.mjs && node scripts/check-nil-predicate.mjs && node scripts/check-monotonic-clock-js.mjs && node scripts/check-helper-inference.mjs",
         "check-js-ffi-source": "cargo build --bin calcit && node scripts/check-js-ffi-source.mjs",
         "check-literal-paths": "cargo run --bin calcit -- calcit/bench-literal-paths.cirru && cargo run --bin calcit -- --emit-path target/literal-path-js calcit/bench-literal-paths.cirru js && node scripts/bench-literal-paths.mjs",
         "check-typed-method-rem": "cargo run --bin calcit -- calcit/fibo.cirru && cargo run --bin calcit -- --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
@@ -31,8 +31,9 @@
         "bench-typed-method-rem": "cargo build --release --bin calcit && yarn compile && target/release/calcit calcit/fibo.cirru && node scripts/bench-typed-method-rem-native.mjs && target/release/calcit --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
         "bench-struct-index": "yarn compile && node scripts/bench-struct-index.mjs",
         "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-        "check-all": "yarn compile && yarn check-js-runtime && node scripts/check-file-read-names.mjs && node scripts/check-enum-impl-cycle.mjs && node scripts/check-typed-source-alias.mjs && node scripts/check-parse-boundary.mjs && yarn check-js-ffi-source && yarn check-strict-default && yarn check-agent-interface && node --test scripts/core-api-contract.test.mjs && node scripts/core-api-contract.mjs && yarn try-core-tests && yarn check-core-dynamic-classification && yarn try-rs && yarn try-js && node scripts/check-struct-field-js.mjs && yarn try-ir && yarn try-wasm && yarn check-literal-paths && yarn check-typed-method-rem",
+        "check-all": "yarn compile && yarn check-js-runtime && node scripts/check-file-read-names.mjs && node scripts/check-enum-impl-cycle.mjs && node scripts/check-typed-source-alias.mjs && node scripts/check-parse-boundary.mjs && yarn check-js-ffi-source && yarn check-strict-default && yarn check-agent-interface && node --test scripts/core-api-contract.test.mjs && node scripts/core-api-contract.mjs && yarn try-core-tests && yarn check-core-tests && yarn check-core-dynamic-classification && yarn try-rs && yarn try-js && node scripts/check-struct-field-js.mjs && yarn try-ir && yarn try-wasm && yarn check-literal-paths && yarn check-typed-method-rem",
         "check-strict-default": "cargo build --bin calcit && node scripts/check-strict-default.mjs && node scripts/check-known-assertion.mjs && node scripts/check-spread-boundary.mjs",
+        "check-core-tests": "node --test scripts/core-test-protocol.test.mjs && cargo build --bin calcit && node scripts/run-core-tests.mjs && node scripts/run-core-tests.mjs --snapshot calcit/test-traits.cirru --target test-traits.main/test-qualified-contains-boundary --backend native,js",
         "check-agent-interface": "cargo build --bin calcit && node scripts/check-agent-interface.mjs",
         "try-all": "yarn check-all",
         "try-core-tests": "cargo run --bin calcit -- src/cirru/calcit-core.cirru test --tag unit --summary-only --require-match",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.29.0-alpha.2",
+  "version": "0.29.0-alpha.23",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",
@@ -21,7 +21,7 @@
     "test-rs": "cargo test -q",
     "test-fail": "cargo test -q --bin calcit type_fail_",
     "test-snippets": "cargo test -q snippets::tests",
-    "check-js-runtime": "node scripts/check-js-runtime-identity.mjs && cargo build --bin calcit && node scripts/check-string-unicode.mjs && node scripts/check-numeric-predicate.mjs && node scripts/check-predicate-method-names.mjs && node scripts/check-map-add-trait-boundary.mjs && node scripts/check-typed-string-conversions.mjs && node scripts/check-identity-conversion-fix.mjs && node scripts/check-nil-predicate.mjs && node scripts/check-monotonic-clock-js.mjs && node scripts/check-helper-inference.mjs",
+    "check-js-runtime": "node scripts/check-js-runtime-identity.mjs && cargo build --bin calcit && node scripts/check-string-unicode.mjs && node scripts/check-map-add-trait-boundary.mjs && node scripts/check-typed-string-conversions.mjs && node scripts/check-identity-conversion-fix.mjs && node scripts/check-nil-predicate.mjs && node scripts/check-monotonic-clock-js.mjs && node scripts/check-helper-inference.mjs",
     "check-js-ffi-source": "cargo build --bin calcit && node scripts/check-js-ffi-source.mjs",
     "check-literal-paths": "cargo run --bin calcit -- calcit/bench-literal-paths.cirru && cargo run --bin calcit -- --emit-path target/literal-path-js calcit/bench-literal-paths.cirru js && node scripts/bench-literal-paths.mjs",
     "check-typed-method-rem": "cargo run --bin calcit -- calcit/fibo.cirru && cargo run --bin calcit -- --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
@@ -31,8 +31,9 @@
     "bench-typed-method-rem": "cargo build --release --bin calcit && yarn compile && target/release/calcit calcit/fibo.cirru && node scripts/bench-typed-method-rem-native.mjs && target/release/calcit --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
     "bench-struct-index": "yarn compile && node scripts/bench-struct-index.mjs",
     "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-    "check-all": "yarn compile && yarn check-js-runtime && node scripts/check-file-read-names.mjs && node scripts/check-enum-impl-cycle.mjs && node scripts/check-typed-source-alias.mjs && node scripts/check-parse-boundary.mjs && yarn check-js-ffi-source && yarn check-strict-default && yarn check-agent-interface && node --test scripts/core-api-contract.test.mjs && node scripts/core-api-contract.mjs && yarn try-core-tests && yarn check-core-dynamic-classification && yarn try-rs && yarn try-js && node scripts/check-struct-field-js.mjs && yarn try-ir && yarn try-wasm && yarn check-literal-paths && yarn check-typed-method-rem",
+    "check-all": "yarn compile && yarn check-js-runtime && node scripts/check-file-read-names.mjs && node scripts/check-enum-impl-cycle.mjs && node scripts/check-typed-source-alias.mjs && node scripts/check-parse-boundary.mjs && yarn check-js-ffi-source && yarn check-strict-default && yarn check-agent-interface && node --test scripts/core-api-contract.test.mjs && node scripts/core-api-contract.mjs && yarn try-core-tests && yarn check-core-tests && yarn check-core-dynamic-classification && yarn try-rs && yarn try-js && node scripts/check-struct-field-js.mjs && yarn try-ir && yarn try-wasm && yarn check-literal-paths && yarn check-typed-method-rem",
     "check-strict-default": "cargo build --bin calcit && node scripts/check-strict-default.mjs && node scripts/check-known-assertion.mjs && node scripts/check-spread-boundary.mjs",
+    "check-core-tests": "node --test scripts/core-test-protocol.test.mjs && cargo build --bin calcit && node scripts/run-core-tests.mjs && node scripts/run-core-tests.mjs --snapshot calcit/test-traits.cirru --target test-traits.main/test-qualified-contains-boundary --backend native,js",
     "check-agent-interface": "cargo build --bin calcit && node scripts/check-agent-interface.mjs",
     "try-all": "yarn check-all",
     "try-core-tests": "cargo run --bin calcit -- src/cirru/calcit-core.cirru test --tag unit --summary-only --require-match",