@calcit/procs 0.28.0-alpha.3 → 0.29.0-alpha.1

package/lib/calcit-data.d.mts

@@ -27,6 +27,8 @@ export type CalcitFn = (...xs: CalcitValue[]) => CalcitValue;
 export declare let getStringName: (x: CalcitValue) => string;
 /** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
 export declare function compareTagNames(x: CalcitTag, y: CalcitTag): number;
+/** Compare scalar values, matching Rust string ordering rather than UTF-16. */
+export declare function compareUnicodeStrings(x: string, y: string): number;
 export declare function tagNamesAreCanonical(fields: CalcitTag[]): boolean;
 export declare function canonicalizeTagPairs<T>(fields: CalcitTag[], values: T[], context: string): [CalcitTag[], T[]];
 /** returns -1 when not found */

package/lib/calcit-data.mjs

@@ -107,11 +107,15 @@ export let getStringName = (x) => {
 };
 /** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
 export function compareTagNames(x, y) {
+    return compareUnicodeStrings(x.value, y.value);
+}
+/** Compare scalar values, matching Rust string ordering rather than UTF-16. */
+export function compareUnicodeStrings(x, y) {
     let xIdx = 0;
     let yIdx = 0;
-    while (xIdx < x.value.length && yIdx < y.value.length) {
-        const xCode = x.value.codePointAt(xIdx);
-        const yCode = y.value.codePointAt(yIdx);
+    while (xIdx < x.length && yIdx < y.length) {
+        const xCode = x.codePointAt(xIdx);
+        const yCode = y.codePointAt(yIdx);
         if (xCode < yCode)
             return -1;
         if (xCode > yCode)
@@ -119,9 +123,9 @@ export function compareTagNames(x, y) {
         xIdx += xCode > 0xffff ? 2 : 1;
         yIdx += yCode > 0xffff ? 2 : 1;
     }
-    if (xIdx < x.value.length)
+    if (xIdx < x.length)
         return 1;
-    if (yIdx < y.value.length)
+    if (yIdx < y.length)
         return -1;
     return 0;
 }
@@ -221,6 +225,9 @@ let defaultHash_struct = valueHash("struct:");
 let defaultHash_enum = valueHash("enum:");
 let defaultHash_cirru_quote = valueHash("cirru-quote:");
 let defaultHash_unknown = valueHash("unknown:");
+let defaultHash_buffer = valueHash("buffer:");
+/** Identity hashes for host values, kept outside the objects so frozen or DOM objects are never mutated. */
+let hostValueHashes = new WeakMap();
 let fnHashCounter = 0;
 let jsObjectHashCounter = 0;
 export let hashFunction = (x) => {
@@ -261,15 +268,20 @@ export let hashFunction = (x) => {
     if (typeof x === "function") {
         // method values are closures created on the fly (see invoke_method_closure);
         // hash by method name so equal methods share the same hash, matching isEqual
+        // cache in a WeakMap instead of writing onto the function, so frozen functions hash safely
+        const cachedFn = hostValueHashes.get(x);
+        if (cachedFn != null) {
+            return cachedFn;
+        }
         const methodName = x.__calcitMethodName;
         if (methodName != null) {
             let h = mergeValueHash(defaultHash_fn, methodName);
-            x[calcit_dirty_hash_key] = h;
+            hostValueHashes.set(x, h);
             return h;
         }
         fnHashCounter = fnHashCounter + 1;
         let h = mergeValueHash(defaultHash_fn, fnHashCounter);
-        x[calcit_dirty_hash_key] = h;
+        hostValueHashes.set(x, h);
         return h;
     }
     if (x instanceof CalcitRef) {
@@ -344,6 +356,8 @@ export let hashFunction = (x) => {
     }
     if (x instanceof CalcitStructValue) {
         let base = defaultHash_record;
+        base = mergeValueHash(base, hashFunction(x.name));
+        base = mergeValueHash(base, hashFunction(x.structRef.definitionRef));
         for (let idx = 0; idx < x.fields.length; idx++) {
             base = mergeValueHash(base, hashFunction(x.fields[idx]));
             base = mergeValueHash(base, hashFunction(x.values[idx]));
@@ -391,15 +405,28 @@ export let hashFunction = (x) => {
         base = hashCirru(base, x.value);
         return base;
     }
-    console.warn(`[warn] calcit-js has no method for hashing this: ${x}`);
-    // currently we use dirty solution here to generate a custom hash
-    // probably happening in .to-pairs of maps, putting a js object into a set
-    // better forbid this, use .to-list instead
-    let hashJsObject = defaultHash_unknown;
+    if (x instanceof Uint8Array) {
+        // Buffers are values: equal bytes must hash equally, matching native Buffer equality.
+        let base = mergeValueHash(defaultHash_buffer, x.length);
+        for (let idx = 0; idx < x.length; idx++) {
+            base = mergeValueHash(base, x[idx]);
+        }
+        return base;
+    }
+    if (typeof x === "object" || typeof x === "function") {
+        // Host values compare by identity, so they hash by identity as well.
+        let cached = hostValueHashes.get(x);
+        if (cached != null) {
+            return cached;
+        }
+        jsObjectHashCounter = jsObjectHashCounter + 1;
+        let hashHostValue = mergeValueHash(defaultHash_unknown, jsObjectHashCounter);
+        hostValueHashes.set(x, hashHostValue);
+        return hashHostValue;
+    }
+    console.warn(`[warn] calcit-js has no method for hashing this: ${String(x)}`);
     jsObjectHashCounter = jsObjectHashCounter + 1;
-    hashJsObject = mergeValueHash(hashJsObject, jsObjectHashCounter);
-    x[calcit_dirty_hash_key] = hashJsObject;
-    return hashJsObject;
+    return mergeValueHash(defaultHash_unknown, jsObjectHashCounter);
 };
 /// traverse Cirru tree to make unique hash
 let hashCirru = (base, x) => {
@@ -758,6 +785,9 @@ export let _$n__$e_ = (x, y) => {
             if (x.name !== y.name) {
                 return false;
             }
+            if (x.structRef.definitionRef !== y.structRef.definitionRef) {
+                return false;
+            }
             if (!fieldsEqual(x.fields, y.fields)) {
                 return false;
             }
@@ -817,6 +847,22 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
+    if (x instanceof Uint8Array) {
+        if (!(y instanceof Uint8Array) || x.length !== y.length) {
+            return false;
+        }
+        for (let idx = 0; idx < x.length; idx++) {
+            if (x[idx] !== y[idx]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (tx === "object") {
+        // Host objects (DOM nodes, JS class instances, BufList) compare by identity;
+        // identical references were accepted at the top of this function.
+        return false;
+    }
     throw new Error("Missing handler for this type");
 };
 // overwrite internary comparator of ternary-tree

package/lib/calcit.procs.d.mts

@@ -48,6 +48,7 @@ export declare const calcit_package_json: {
         url: string;
     };
     dependencies: {
+        "@calcit/finger-vec": string;
         "@calcit/ternary-tree": string;
         "@cirru/parser.ts": string;
         "@cirru/writer.ts": string;
@@ -86,7 +87,9 @@ import { CalcitSet } from "./js-set.mjs";
 import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitCirruQuote } from "./js-cirru.mjs";
 export declare let type_of: (x: any) => CalcitTag;
-export declare let _$n_trait_$o__$o_new: (name: CalcitValue, methods: CalcitValue) => CalcitTrait;
+/** Check host member shape without invoking methods or claiming their signature is verified. */
+export declare const js_cast: (value: unknown, trait: string, fields: readonly string[], methods: readonly string[]) => object;
+export declare let _$n_trait_$o__$o_new: (name: CalcitValue, methods: CalcitValue, parents?: CalcitValue) => CalcitTrait;
 export declare let _$n_assert_traits: (value: CalcitValue, traitDef: CalcitValue) => CalcitValue;
 export declare let defstruct: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStructDef;
 export declare let defenum: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnumDef;
@@ -185,6 +188,7 @@ 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`. */
 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;
@@ -355,6 +359,7 @@ export declare function invoke_method_closure(p: string): (obj: CalcitValue, ...
 export declare function invoke_method(p: string, obj: CalcitValue, ...args: CalcitValue[]): CalcitValue;
 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_to_list: (m: CalcitValue) => CalcitSliceList;
 export declare let _$n_map_$o_keys: (m: CalcitValue) => CalcitSet;

package/lib/calcit.procs.mjs

@@ -33,7 +33,7 @@ import { CalcitSet } from "./js-set.mjs";
 import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { to_calcit_data, extract_cirru_edn, extract_cirru_edn_for_typed, CalcitCirruQuote } from "./js-cirru.mjs";
 import { TypedEdnSetView } from "./typed-edn.mjs";
-import { initTernaryTreeList } from "@calcit/ternary-tree";
+import { FingerVec } from "@calcit/finger-vec";
 let inNodeJs = typeof process !== "undefined" && process?.release?.name === "node";
 export let type_of = (x) => {
     if (typeof x === "string") {
@@ -104,6 +104,52 @@ export let type_of = (x) => {
     }
     throw new Error(`Unknown data ${x}`);
 };
+// The intrinsic getter reads typed-array slots across realms, ignoring a forged Symbol.toStringTag.
+const typedArrayTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get;
+/** Check host member shape without invoking methods or claiming their signature is verified. */
+export const js_cast = (value, trait, fields, methods) => {
+    const fail = (detail, cause) => {
+        const error = new TypeError(`js-cast ${trait}: ${detail}`);
+        Object.defineProperty(error, "cause", { value: cause, configurable: true });
+        throw error;
+    };
+    // Calcit objects (including Buffers) are not interchangeable with external handles.
+    // Keep the runtime's own value classification authoritative instead of another registry.
+    let host;
+    try {
+        host = value !== null && typeof value === "object"
+            && !(ArrayBuffer.isView(value) && typedArrayTag.call(value) === "Uint8Array")
+            && !(value instanceof CalcitRecur) && type_of(value).value === "js-object";
+    }
+    catch (cause) {
+        return fail("host classification failed", cause);
+    }
+    if (!host || value === null || typeof value !== "object")
+        return fail("expected a JavaScript host object");
+    for (const field of fields) {
+        let present;
+        try {
+            present = field in value;
+        }
+        catch (cause) {
+            return fail(`field ${JSON.stringify(field)} lookup failed`, cause);
+        }
+        if (!present)
+            return fail(`missing field ${JSON.stringify(field)}`);
+    }
+    for (const method of methods) {
+        let member;
+        try {
+            member = Reflect.get(value, method);
+        }
+        catch (cause) {
+            return fail(`method ${JSON.stringify(method)} lookup failed`, cause);
+        }
+        if (typeof member !== "function")
+            return fail(`method ${JSON.stringify(method)} is not callable`);
+    }
+    return value;
+};
 const list_items = (item) => {
     if (item instanceof CalcitList || item instanceof CalcitSliceList) {
         return Array.from(item.items());
@@ -161,9 +207,9 @@ const trimDataDefinitionEntries = (entries) => {
     }
     return entries.slice(start);
 };
-export let _$n_trait_$o__$o_new = function (name, methods) {
-    if (arguments.length !== 2)
-        throw new Error("&trait::new expected 2 arguments");
+export let _$n_trait_$o__$o_new = function (name, methods, parents) {
+    if (arguments.length !== 2 && arguments.length !== 3)
+        throw new Error("&trait::new expected 2 or 3 arguments");
     const items = list_items(methods);
     const methodNames = [];
     const methodTypes = [];
@@ -175,7 +221,39 @@ export let _$n_trait_$o__$o_new = function (name, methods) {
         methodNames.push(pair[0]);
         methodTypes.push(pair[1]);
     }
-    return new CalcitTrait(name, methodNames, methodTypes);
+    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)}`);
+        }
+    }
+    const traitDef = new CalcitTrait(name, methodNames, methodTypes, requires);
+    const owners = new Map();
+    for (const reachable of traitDef.reachable()) {
+        for (const member of reachable.methods) {
+            const owner = owners.get(member.value);
+            if (owner != null && owner !== reachable) {
+                throw new Error(`member \`${member.value}\` is declared by both ${owner.name.toString()} and ${reachable.name.toString()}; keep it on one trait`);
+            }
+            owners.set(member.value, reachable);
+        }
+    }
+    return traitDef;
+};
+/** Every attached impl needs impls of all traits its origin requires on the same type. */
+let checkRequiredTraitImpls = (impls, procName) => {
+    for (const impl of impls) {
+        const origin = impl?.origin;
+        if (origin == null)
+            continue;
+        for (const required of origin.reachable()) {
+            if (required === origin)
+                continue;
+            if (!impls.some((candidate) => candidate?.origin === required)) {
+                throw new Error(`${procName}: an impl of trait ${origin.name.toString()} requires an impl of trait ${required.name.toString()} on the same type; attach one before or with it`);
+            }
+        }
+    }
 };
 export let _$n_assert_traits = function (value, traitDef) {
     if (arguments.length !== 2)
@@ -205,6 +283,10 @@ export let _$n_assert_traits = function (value, traitDef) {
     if (missing.length > 0) {
         throw new Error(`assert-traits failed: impl ${selected.name.toString()} for trait ${traitDef.name.toString()} is incomplete. Missing: ${missing.join(" ")}`);
     }
+    const unmet = traitDef.reachable().find((required) => required !== traitDef && !impls.some((impl) => impl?.origin === required));
+    if (unmet != null) {
+        throw new Error(`assert-traits failed: ${toString(value, true)} implements ${traitDef.name.toString()} but not its required trait ${unmet.name.toString()}`);
+    }
     return value;
 };
 export let defstruct = (name, ...entries) => {
@@ -597,6 +679,7 @@ export let _$n_enum_$o_impl_traits = function (x, ...traits) {
     if (!(x instanceof CalcitEnumValue))
         throw new Error("&enum:impl-traits expects an enum value");
     const impls = traits.map((trait) => coerce_impl(trait, "&enum:impl-traits"));
+    checkRequiredTraitImpls([...(x.enumPrototype?.impls ?? []), ...impls], "&enum:impl-traits");
     let proto = x.enumPrototype;
     if (proto == null) {
         const tagName = x.tag instanceof CalcitTag ? x.tag : newTag("tag");
@@ -733,7 +816,8 @@ export let _$n_struct_$o_impl_traits = function (xs, ...traits) {
     if (!(xs instanceof CalcitStructValue))
         throw new Error("&struct:impl-traits expected a struct value");
     const impls = traits.map((trait) => coerce_impl(trait, "&struct:impl-traits"));
-    const nextStruct = new CalcitStructDef(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(impls));
+    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);
     return new CalcitStructValue(xs.name, xs.fields, xs.values, nextStruct);
 };
 export let _$n_struct_def_$o_impl_traits = function (xs, ...traits) {
@@ -743,13 +827,15 @@ export let _$n_struct_def_$o_impl_traits = function (xs, ...traits) {
         throw new Error("&struct-def:impl-traits expected a struct definition");
     const addedImpls = traits.map((trait) => coerce_impl(trait, "&struct-def:impl-traits"));
     const baseImpls = xs.impls ?? [];
-    return new CalcitStructDef(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls));
+    checkRequiredTraitImpls(baseImpls.concat(addedImpls), "&struct-def:impl-traits");
+    return new CalcitStructDef(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls), xs.definitionRef);
 };
 export let _$n_enum_def_$o_impl_traits = function (xs, ...traits) {
     if (traits.length < 1)
         throw new Error("&enum-def:impl-traits takes 2+ arguments");
     const addedImpls = traits.map((trait) => coerce_impl(trait, "&enum-def:impl-traits"));
     if (xs instanceof CalcitEnumDef) {
+        checkRequiredTraitImpls([...(xs.impls ?? []), ...addedImpls], "&enum-def:impl-traits");
         return xs.withImpls(addedImpls);
     }
     throw new Error("&enum-def:impl-traits expected an enum definition");
@@ -1114,8 +1200,15 @@ 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`. */
 export let _$n_number_$o_rem = (a, b) => {
-    return 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)}`);
+    }
+    if (b === 0) {
+        throw new Error("&number:rem divisor must not be zero");
+    }
+    return (a % b) + 0;
 };
 export let _$n_number_$o_fits_$q_ = (value, target) => {
     if (!(target instanceof CalcitTag)) {
@@ -1476,7 +1569,7 @@ export let _$n_get_env = (name, v0) => {
 export let get_env = _$n_get_env;
 export let _$n_get_args = () => {
     const args = inNodeJs ? process.argv : [];
-    return new CalcitList(initTernaryTreeList(args));
+    return new CalcitList(FingerVec.from(args));
 };
 export let get_args = _$n_get_args;
 /** Block for an integral millisecond duration and preserve host failures as Result values. */
@@ -2679,6 +2772,7 @@ export function _$n_inspect_methods(obj, note) {
     console.log("\n");
     return obj;
 }
+/** Dispatch through one nominal origin; duplicate implementations never select by order. */
 export function _$n_trait_call(traitDef, method, obj, ...args) {
     if (arguments.length < 3) {
         throw new Error("&trait-call expected 3+ arguments (trait, method, receiver, & args)");
@@ -2697,20 +2791,20 @@ export function _$n_trait_call(traitDef, method, obj, ...args) {
         throw new Error(`&trait-call cannot resolve impls for: ${toString(obj, true)}`);
     }
     const impls = pair[0];
-    const reverse = obj instanceof CalcitStructValue || obj instanceof CalcitEnumValue || obj instanceof CalcitStructDef || obj instanceof CalcitEnumDef;
-    let idx = reverse ? impls.length - 1 : 0;
-    while (reverse ? idx >= 0 : idx < impls.length) {
-        const impl = impls[idx];
-        if (impl != null && impl.origin === traitDef) {
-            const fn = impl.getOrNil(methodName);
-            if (fn != null) {
-                if (typeof fn !== "function") {
-                    throw new Error(`&trait-call: method :${methodName} for trait ${traitDef.name.toString()} is not a function: ${toString(fn, true)}`);
-                }
-                return fn(obj, ...args);
+    // Explicit trait selection disambiguates origins, not implementations of
+    // one origin. Check all candidates before invoking any method.
+    const matchingImpls = impls.filter((impl) => impl != null && impl.origin === traitDef);
+    if (matchingImpls.length > 1) {
+        throw new Error(`[E_DUPLICATE_TRAIT_IMPL] &trait-call: trait ${traitDef.name.toString()} has ${matchingImpls.length} implementations attached to the same receiver; dispatch cannot choose between duplicate impls`);
+    }
+    if (matchingImpls.length === 1) {
+        const fn = matchingImpls[0].getOrNil(methodName);
+        if (fn != null) {
+            if (typeof fn !== "function") {
+                throw new Error(`&trait-call: method :${methodName} for trait ${traitDef.name.toString()} is not a function: ${toString(fn, true)}`);
             }
+            return fn(obj, ...args);
         }
-        idx += reverse ? -1 : 1;
     }
     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.`);
 }

package/lib/js-list.d.mts

@@ -1,10 +1,11 @@
+import { FingerVec } from "@calcit/finger-vec";
+import { Hash } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
-import { TernaryTreeList, Hash } from "@calcit/ternary-tree";
 import { CalcitFn } from "./calcit-data.mjs";
 export declare class CalcitList {
-    value: TernaryTreeList<CalcitValue>;
+    value: FingerVec<CalcitValue>;
     cachedHash: Hash;
-    constructor(value: TernaryTreeList<CalcitValue>);
+    constructor(value: FingerVec<CalcitValue>);
     len(): number;
     get(idx: number): CalcitValue;
     assoc(idx: number, v: CalcitValue): CalcitList;

package/lib/js-list.mjs

@@ -1,6 +1,5 @@
-import * as ternaryTree from "@calcit/ternary-tree";
+import { FingerVec } from "@calcit/finger-vec";
 import { isLiteral } from "./js-primes.mjs";
-import { initTernaryTreeList, initTernaryTreeListFromRange, listLen, listGet, assocList, listToItems, dissocList, assocBefore, assocAfter, } from "@calcit/ternary-tree";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
 import { CalcitEnumValue } from "./js-enum-value.mjs";
@@ -10,35 +9,38 @@ export class CalcitList {
     constructor(value) {
         this.cachedHash = null;
         if (value == null) {
-            this.value = initTernaryTreeList([]);
+            this.value = FingerVec.empty();
         }
         else {
             this.value = value;
         }
     }
     len() {
-        return listLen(this.value);
+        return this.value.size;
     }
     get(idx) {
-        if (this.len() === 0) {
+        if (this.value.size === 0) {
             return null;
         }
-        return listGet(this.value, idx);
+        if (idx < 0 || idx >= this.value.size) {
+            throw new Error(`Index ${idx} out of range for list of size ${this.value.size}`);
+        }
+        return this.value.get(idx);
     }
     assoc(idx, v) {
-        return new CalcitList(assocList(this.value, idx, v));
+        return new CalcitList(this.value.assoc(idx, v));
     }
     assocBefore(idx, v) {
-        return new CalcitList(assocBefore(this.value, idx, v));
+        return new CalcitList(this.value.assocBefore(idx, v));
     }
     assocAfter(idx, v) {
-        return new CalcitList(assocAfter(this.value, idx, v));
+        return new CalcitList(this.value.assocAfter(idx, v));
     }
     dissoc(idx) {
-        return new CalcitList(dissocList(this.value, idx));
+        return new CalcitList(this.value.dissoc(idx));
     }
     slice(from, to) {
-        return new CalcitList(ternaryTree.slice(this.value, from, to));
+        return new CalcitList(this.value.slice(from, to));
     }
     toString(shorter = false, disableJsDataWarning = false) {
         let result = "";
@@ -53,43 +55,46 @@ export class CalcitList {
         return `([]${result})`;
     }
     isEmpty() {
-        return this.len() === 0;
+        return this.value.size === 0;
     }
     /** usage: `for of` */
     items() {
-        return listToItems(this.value);
+        return this.value.items();
     }
     append(v) {
-        return new CalcitList(ternaryTree.append(this.value, v));
+        return new CalcitList(this.value.pushRight(v));
     }
     prepend(v) {
-        return new CalcitList(ternaryTree.prepend(this.value, v));
+        return new CalcitList(this.value.pushLeft(v));
     }
     first() {
-        return ternaryTree.first(this.value);
+        if (this.value.size === 0) {
+            throw new Error("Cannot get from empty list");
+        }
+        return this.value.first();
     }
     rest() {
-        return new CalcitList(ternaryTree.rest(this.value));
+        return new CalcitList(this.value.rest());
     }
     concat(ys) {
         if (ys instanceof CalcitSliceList) {
-            return new CalcitList(ternaryTree.concat(this.value, ys.turnListMode().value));
+            return new CalcitList(this.value.concat(ys.turnListMode().value));
         }
         else if (ys instanceof CalcitList) {
-            return new CalcitList(ternaryTree.concat(this.value, ys.value));
+            return new CalcitList(this.value.concat(ys.value));
         }
         else {
             throw new Error(`Unknown data to concat: ${ys}`);
         }
     }
     map(f) {
-        return new CalcitList(ternaryTree.listMapValues(this.value, f));
+        return new CalcitList(this.value.map(f));
     }
     toArray() {
-        return [...ternaryTree.listToItems(this.value)];
+        return this.value.toArray();
     }
     reverse() {
-        return new CalcitList(ternaryTree.reverse(this.value));
+        return new CalcitList(this.value.reverse());
     }
     nestedDataInChildren() {
         let size = this.len();
@@ -98,6 +103,7 @@ export class CalcitList {
                 return true;
             }
         }
+        return false;
     }
 }
 // represent append-only immutable list in Array slices
@@ -115,7 +121,7 @@ export class CalcitSliceList {
         if (this.cachedTreeListRef != null) {
             return this.cachedTreeListRef;
         }
-        let ret = new CalcitList(initTernaryTreeListFromRange(this.value, this.start, this.end));
+        let ret = new CalcitList(FingerVec.fromRange(this.value, this.start, this.end));
         this.cachedTreeListRef = ret;
         return ret;
     }
@@ -241,8 +247,8 @@ export class CalcitSliceList {
     }
     map(f) {
         let ys = [];
-        for (let x in sliceGenerator(this.value, this.start, this.end)) {
-            ys.push(f(x));
+        for (let idx = this.start; idx < this.end; idx++) {
+            ys.push(f(this.value[idx]));
         }
         return new CalcitSliceList(ys);
     }

package/lib/js-primes.mjs

@@ -1,4 +1,4 @@
-import { CalcitTag, CalcitSymbol, CalcitRecur } from "./calcit-data.mjs";
+import { CalcitTag, CalcitSymbol, CalcitRecur, compareUnicodeStrings } from "./calcit-data.mjs";
 import { CalcitRef } from "./js-ref.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitStructValue } from "./js-struct-value.mjs";
@@ -101,6 +101,17 @@ let rawCompare = (x, y) => {
         return 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);
+    for (let i = 0; i < n; i++) {
+        let order = _$n_compare(xs[i], ys[i]);
+        if (order !== 0)
+            return order;
+    }
+    return rawCompare(xs.length, ys.length);
+};
+let listToArray = (x) => Array.from(x.items());
 export let _$n_compare = (a, b) => {
     if (a === b)
         return 0;
@@ -123,8 +134,72 @@ export let _$n_compare = (a, b) => {
                 return rawCompare(a, b);
             case PseudoTypeIndex.ref:
                 return rawCompare(a.path, b.path);
+            case PseudoTypeIndex.struct_value: {
+                const left = a;
+                const right = b;
+                const nameOrder = compareUnicodeStrings(left.name.value, right.name.value);
+                if (nameOrder !== 0)
+                    return nameOrder;
+                const leftRef = left.structRef.definitionRef;
+                const rightRef = right.structRef.definitionRef;
+                if (leftRef !== rightRef) {
+                    if (leftRef == null)
+                        return -1;
+                    if (rightRef == null)
+                        return 1;
+                    return compareUnicodeStrings(leftRef, rightRef);
+                }
+                for (let index = 0; index < Math.min(left.fields.length, right.fields.length); index++) {
+                    const fieldOrder = compareUnicodeStrings(left.fields[index].value, right.fields[index].value);
+                    if (fieldOrder !== 0)
+                        return fieldOrder;
+                }
+                const fieldCountOrder = rawCompare(left.fields.length, right.fields.length);
+                if (fieldCountOrder !== 0)
+                    return fieldCountOrder;
+                for (let index = 0; index < Math.min(left.values.length, right.values.length); index++) {
+                    const valueOrder = _$n_compare(left.values[index], right.values[index]);
+                    if (valueOrder !== 0)
+                        return valueOrder;
+                }
+                return rawCompare(left.values.length, right.values.length);
+            }
             case PseudoTypeIndex.cirru_quote:
                 return rawCompare(a, b); // TODO not stable
+            case PseudoTypeIndex.list:
+                return compareSequences(listToArray(a), listToArray(b));
+            case PseudoTypeIndex.enum_value: {
+                const left = a;
+                const right = b;
+                const tagOrder = _$n_compare(left.tag, right.tag);
+                if (tagOrder !== 0)
+                    return tagOrder;
+                return compareSequences(left.extra, right.extra);
+            }
+            case PseudoTypeIndex.set: {
+                // like native: smaller sets first, then the sorted elements
+                const left = Array.from(a.values());
+                const right = Array.from(b.values());
+                const sizeOrder = rawCompare(left.length, right.length);
+                if (sizeOrder !== 0)
+                    return sizeOrder;
+                return compareSequences(left.sort(_$n_compare), right.sort(_$n_compare));
+            }
+            case PseudoTypeIndex.map: {
+                // like native: smaller maps first, then the (key, value) pairs sorted by key and value
+                const sortPairs = (pairs) => pairs.sort((x, y) => _$n_compare(x[0], y[0]) || _$n_compare(x[1], y[1]));
+                const left = sortPairs(a.pairs());
+                const right = sortPairs(b.pairs());
+                const sizeOrder = rawCompare(left.length, right.length);
+                if (sizeOrder !== 0)
+                    return sizeOrder;
+                for (let i = 0; i < left.length; i++) {
+                    const order = _$n_compare(left[i][0], right[i][0]) || _$n_compare(left[i][1], right[i][1]);
+                    if (order !== 0)
+                        return order;
+                }
+                return 0;
+            }
             default:
                 // TODO, need more accurate solution
                 if (a < b) {

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

@@ -7,7 +7,10 @@ export declare class CalcitStructDef {
     fieldTypes: CalcitValue[];
     impls: CalcitImpl[];
     cachedHash: number;
-    constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls?: CalcitImpl[]);
+    readonly definitionRef: string | null;
+    constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls?: CalcitImpl[], definitionRef?: string | 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;

package/lib/js-struct-def.mjs

@@ -1,20 +1,21 @@
 import { canonicalizeTagPairs, toString } from "./calcit-data.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 export class CalcitStructDef {
-    constructor(name, fields, fieldTypes, impls = []) {
+    constructor(name, fields, fieldTypes, impls = [], definitionRef = null) {
         const [canonicalFields, canonicalTypes] = canonicalizeTagPairs(fields, fieldTypes, "CalcitStructDef");
         this.name = name;
         this.fields = canonicalFields;
         this.fieldTypes = canonicalTypes;
-        this.impls = impls;
+        this.impls = impls ?? [];
         this.cachedHash = null;
+        this.definitionRef = definitionRef;
     }
     withImpls(impls) {
         if (impls instanceof CalcitImpl) {
-            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, [impls]);
+            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, [impls], this.definitionRef);
         }
         else if (Array.isArray(impls)) {
-            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, impls);
+            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, impls, this.definitionRef);
         }
         throw new Error("Expected an impl as implementation");
     }
@@ -32,3 +33,10 @@ export class CalcitStructDef {
         return parts.join("");
     }
 }
+/** Match native definition binding without replacing 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);
+    }
+    return value;
+}

package/lib/js-struct-value.mjs

@@ -116,7 +116,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));
+        let nextStruct = new CalcitStructDef(this.name, this.fields, this.structRef.fieldTypes, this.structRef.impls.concat(nextImpls), this.structRef.definitionRef);
         return new CalcitStructValue(this.name, this.fields, this.values, nextStruct);
     }
 }

package/lib/js-trait.d.mts

@@ -4,6 +4,9 @@ export declare class CalcitTrait {
     name: CalcitTag;
     methods: CalcitTag[];
     methodTypes: CalcitValue[];
-    constructor(name: CalcitValue, methods: CalcitValue[], methodTypes: CalcitValue[]);
+    requires: CalcitTrait[];
+    constructor(name: CalcitValue, methods: CalcitValue[], methodTypes: CalcitValue[], requires?: CalcitTrait[]);
+    /** This trait and every transitively required trait, each origin once. */
+    reachable(): CalcitTrait[];
     toString(disableJsDataWarning?: boolean): string;
 }

package/lib/js-trait.mjs

@@ -1,9 +1,26 @@
 import { castTag } from "./calcit-data.mjs";
 export class CalcitTrait {
-    constructor(name, methods, methodTypes) {
+    constructor(name, methods, methodTypes, requires = []) {
         this.name = castTag(name);
         this.methods = methods.map(castTag);
         this.methodTypes = methodTypes;
+        this.requires = requires;
+    }
+    /** This trait and every transitively required trait, each origin once. */
+    reachable() {
+        const output = [];
+        const visit = (current, active) => {
+            if (active.includes(current)) {
+                throw new Error(`trait requires cycle: ${[...active, current].map((item) => item.name.toString()).join(" -> ")}`);
+            }
+            if (output.includes(current))
+                return;
+            for (const required of current.requires)
+                visit(required, [...active, current]);
+            output.push(current);
+        };
+        visit(this, []);
+        return output;
     }
     toString(disableJsDataWarning = false) {
         const parts = ["(trait ", this.name.toString()];

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.28.0-alpha.3",
+    "version": "0.29.0-alpha.1",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",
@@ -32,7 +32,7 @@
         "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-strict-default": "cargo build --bin calcit && node scripts/check-strict-default.mjs && node scripts/check-known-assertion.mjs",
+        "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-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",
@@ -50,8 +50,9 @@
         "url": "git+https://github.com/calcit-lang/calcit.git"
     },
     "dependencies": {
+        "@calcit/finger-vec": "0.1.1",
         "@calcit/ternary-tree": "0.0.26",
-        "@cirru/parser.ts": "^0.0.9",
+        "@cirru/parser.ts": "0.0.10",
         "@cirru/writer.ts": "^0.1.9"
     },
     "packageManager": "yarn@4.12.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.28.0-alpha.3",
+  "version": "0.29.0-alpha.1",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",
@@ -32,7 +32,7 @@
     "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-strict-default": "cargo build --bin calcit && node scripts/check-strict-default.mjs && node scripts/check-known-assertion.mjs",
+    "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-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",
@@ -50,8 +50,9 @@
     "url": "git+https://github.com/calcit-lang/calcit.git"
   },
   "dependencies": {
+    "@calcit/finger-vec": "0.1.1",
     "@calcit/ternary-tree": "0.0.26",
-    "@cirru/parser.ts": "^0.0.9",
+    "@cirru/parser.ts": "0.0.10",
     "@cirru/writer.ts": "^0.1.9"
   },
   "packageManager": "yarn@4.12.0"