@calcit/procs 0.29.0-alpha.8 → 0.29.0

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.8",
+    "version": "0.29.0",
     "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",