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

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;
@@ -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;
@@ -361,6 +363,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);
 };
@@ -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"));
@@ -2808,6 +2814,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

@@ -12,5 +12,5 @@ export declare class CalcitStructDef {
     withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStructDef;
     toString(disableJsDataWarning?: boolean): string;
 }
-/** Match native definition binding without replacing an alias's existing identity. */
+/** Bind nominal definitions like native, preserving an alias's existing identity. */
 export declare function bind_struct_definition(value: CalcitValue, definitionRef: string): CalcitValue;

package/lib/js-struct-def.mjs

@@ -1,5 +1,7 @@
 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) {
         const [canonicalFields, canonicalTypes] = canonicalizeTagPairs(fields, fieldTypes, "CalcitStructDef");
@@ -33,10 +35,15 @@ export class CalcitStructDef {
         return parts.join("");
     }
 }
-/** Match native definition binding without replacing an alias's existing identity. */
+/** Bind nominal definitions like native, preserving an alias's existing identity. */
 export function bind_struct_definition(value, definitionRef) {
     if (value instanceof CalcitStructDef && value.definitionRef == null) {
         return new CalcitStructDef(value.name, value.fields, value.fieldTypes, value.impls, definitionRef);
     }
+    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

@@ -2,6 +2,14 @@ import { CalcitImpl } from "./js-impl.mjs";
 import { newTag, castTag, toString, 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) => {
+    const fieldType = structRef?.fieldTypes?.[idx];
+    if (fieldType != null && !valueMatchesTypeForm(value, fieldType)) {
+        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;
@@ -44,6 +52,7 @@ export class CalcitStructValue {
         let k_id = castTag(k);
         for (let idx = 0; idx < this.fields.length; idx++) {
             if (this.fields[idx] === k_id) {
+                assertFieldValue(this.structRef, idx, v, "&struct:assoc");
                 values[idx] = v;
             }
             else {
@@ -60,6 +69,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 +82,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);
@@ -234,6 +245,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");
             values[idx] = v;
         }
         return new CalcitStructValue(proto.name, proto.fields, values, proto.structRef);

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) => boolean;

package/lib/js-type-form.mjs

@@ -0,0 +1,167 @@
+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";
+/// 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, as unresolved forms are on the native side.
+export let valueMatchesTypeForm = (value, form) => {
+    if (form instanceof CalcitSliceList || form instanceof CalcitList) {
+        const items = form.toArray();
+        const head = items[0];
+        if (head instanceof CalcitSymbol && head.value === "quote") {
+            return valueMatchesTypeForm(value, items[1]);
+        }
+        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 || valueMatchesTypeForm(value, items[2]);
+            }
+            if (name === "JsNullish") {
+                return value == null || valueMatchesTypeForm(value, items[2]);
+            }
+            return name == null || valueMatchesTypeName(value, name);
+        }
+        return true;
+    }
+    const name = typeFormName(form);
+    return name == null || valueMatchesTypeName(value, name);
+};
+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) => {
+    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 "List":
+        case "list":
+            return isList(value);
+        case "Map":
+        case "map":
+            return isMap(value);
+        case "Set":
+        case "set":
+            return value instanceof CalcitSet;
+        case "Ref":
+        case "ref":
+            return value instanceof CalcitRef;
+        case "Fn":
+        case "fn":
+            return typeof value === "function";
+        case "Struct":
+        case "struct":
+        case "record":
+            return isStructValue(value);
+        case "Enum":
+        case "enum":
+        case "tuple":
+            return value instanceof CalcitEnumValue;
+    }
+    // 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.20",
     "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.20",
   "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",