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

package/lib/calcit.procs.d.mts

@@ -155,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;
@@ -243,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;
@@ -325,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;

package/lib/calcit.procs.mjs

@@ -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!");
     }
@@ -1661,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;
@@ -1947,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";

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;
 }
 /** Bind nominal definitions like native, preserving an alias's existing identity. */
-export declare function bind_struct_definition(value: CalcitValue, definitionRef: string): CalcitValue;
+export declare function bind_struct_definition(value: CalcitValue, definitionRef: string, fieldValidators?: FieldValidator[] | null): CalcitValue;

package/lib/js-struct-def.mjs

@@ -3,7 +3,7 @@ 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;
@@ -11,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");
     }
@@ -36,9 +37,9 @@ export class CalcitStructDef {
     }
 }
 /** Bind nominal definitions like native, preserving an alias's existing identity. */
-export function bind_struct_definition(value, definitionRef) {
+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;

package/lib/js-struct-value.mjs

@@ -1,12 +1,14 @@
 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) => {
+let assertFieldValue = (structRef, idx, value, operation, requireEvidence = false) => {
     const fieldType = structRef?.fieldTypes?.[idx];
-    if (fieldType != null && !valueMatchesTypeForm(value, fieldType)) {
+    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)}`);
     }
 };
@@ -48,17 +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) {
-                assertFieldValue(this.structRef, idx, v, "&struct:assoc");
-                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) {
@@ -127,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);
     }
 }
@@ -192,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) {
@@ -245,7 +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");
+            assertFieldValue(proto.structRef, idx, v, "&struct:with", true);
             values[idx] = v;
         }
         return new CalcitStructValue(proto.name, proto.fields, values, proto.structRef);
@@ -273,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]);
-        }
-        // 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}`);
+    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");
         }
-        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

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

package/lib/js-type-form.mjs

@@ -4,33 +4,42 @@ 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, as unresolved forms are on the native side.
-export let valueMatchesTypeForm = (value, form) => {
+/// 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 valueMatchesTypeForm(value, items[1]);
+            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 || valueMatchesTypeForm(value, items[2]);
+                return value === null ? true : matchTypeForm(value, items[2], requireEvidence);
             }
             if (name === "JsNullish") {
-                return value == null || valueMatchesTypeForm(value, items[2]);
+                return value == null ? true : matchTypeForm(value, items[2], requireEvidence);
             }
-            return name == null || valueMatchesTypeName(value, name);
+            if (name === "Fn" && requireEvidence)
+                return null;
+            return name == null ? (requireEvidence ? null : true) : valueMatchesTypeName(value, name, requireEvidence);
         }
-        return true;
+        return requireEvidence ? null : true;
     }
     const name = typeFormName(form);
-    return name == null || valueMatchesTypeName(value, name);
+    return name == null ? (requireEvidence ? null : true) : valueMatchesTypeName(value, name, requireEvidence);
 };
 let typeFormName = (form) => {
     if (form instanceof CalcitSymbol)
@@ -48,7 +57,7 @@ let typeFormName = (form) => {
 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) => {
+let valueMatchesTypeName = (value, rawName, requireEvidence) => {
     const name = rawName.startsWith("calcit.core/") ? rawName.slice("calcit.core/".length) : rawName;
     switch (name) {
         case "Dynamic":
@@ -106,30 +115,42 @@ let valueMatchesTypeName = (value, rawName) => {
         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 isList(value);
+            return requireEvidence ? null : isList(value);
         case "Map":
         case "map":
-            return isMap(value);
+            return requireEvidence ? null : isMap(value);
         case "Set":
         case "set":
-            return value instanceof CalcitSet;
+            return requireEvidence ? null : value instanceof CalcitSet;
         case "Ref":
         case "ref":
-            return value instanceof CalcitRef;
+            return requireEvidence ? null : value instanceof CalcitRef;
         case "Fn":
         case "fn":
             return typeof value === "function";
         case "Struct":
         case "struct":
         case "record":
-            return isStructValue(value);
+            return requireEvidence ? null : isStructValue(value);
         case "Enum":
         case "enum":
         case "tuple":
-            return value instanceof CalcitEnumValue;
+            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.

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.29.0-alpha.20",
+    "version": "0.29.0-alpha.24",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.29.0-alpha.20",
+  "version": "0.29.0-alpha.24",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",