@calcit/procs 0.13.42 → 0.13.44

package/lib/calcit.procs.mjs

@@ -3,7 +3,7 @@ export const calcit_version = pkg.version;
 export const calcit_package_json = pkg;
 import { parse } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
-import { CalcitSymbol, CalcitTag, CalcitRecur, castTag, newTag, refsRegistry, toString, getStringName, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
+import { CalcitSymbol, CalcitTag, CalcitRecur, castTag, newTag, refsRegistry, toString, getStringName, compareTagNames, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
 import { CalcitRef, atom } from "./js-ref.mjs";
 import { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
@@ -50,9 +50,11 @@ export let type_of = (x) => {
     if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
         return newTag("map");
     }
-    if (x == null) {
+    if (x === null) {
         return newTag("nil");
     }
+    if (x === undefined)
+        return newTag("unit");
     if (x instanceof CalcitRef) {
         return newTag("ref");
     }
@@ -214,7 +216,7 @@ export let defstruct = (name, ...entries) => {
         const fieldType = items[1];
         fields.push({ tag: fieldTag, type: fieldType });
     }
-    fields.sort((a, b) => a.tag.idx - b.tag.idx);
+    fields.sort((a, b) => compareTagNames(a.tag, b.tag));
     for (let i = 1; i < fields.length; i++) {
         if (fields[i - 1].tag.value === fields[i].tag.value) {
             throw new Error(`defstruct duplicated field: ${fields[i].tag.toString()}`);
@@ -237,7 +239,7 @@ export let defenum = (name, ...variants) => {
         const payload = new CalcitSliceList(items.slice(1));
         entries.push({ tag, payload });
     }
-    entries.sort((a, b) => a.tag.idx - b.tag.idx);
+    entries.sort((a, b) => compareTagNames(a.tag, b.tag));
     for (let i = 1; i < entries.length; i++) {
         if (entries[i - 1].tag.value === entries[i].tag.value) {
             throw new Error(`defenum duplicated variant: ${entries[i].tag.toString()}`);
@@ -280,7 +282,7 @@ export let _$n_impl_$o__$o_new = (name, ...pairs) => {
         }
         entries.push({ tag: fieldTag, value });
     }
-    entries.sort((a, b) => a.tag.idx - b.tag.idx);
+    entries.sort((a, b) => compareTagNames(a.tag, b.tag));
     for (let i = 1; i < entries.length; i++) {
         if (entries[i - 1].tag.value === entries[i].tag.value) {
             throw new Error(`&impl::new duplicated field: ${entries[i].tag.toString()}`);
@@ -345,14 +347,26 @@ export function _$n_struct_$o_field_tag(x, idx) {
         throw new Error(`&struct:field-tag index ${i} out of bounds (${x.fields.length})`);
     return x.fields[i];
 }
-export function _$n_struct_$o_nth(x, idx) {
+export function _$n_struct_$o_nth(x, idx, field) {
     if (!(x instanceof CalcitStructValue))
         throw new Error(`&struct:nth expected a struct value, got ${x}`);
+    if (field !== undefined)
+        return x.nthAt(idx, field);
     const i = idx;
     if (i < 0 || i >= x.values.length)
         throw new Error(`&struct:nth index ${i} out of range for struct with ${x.values.length} fields`);
     return x.values[i];
 }
+export function _$n_struct_$o_assoc_at(x, idx, field, value) {
+    if (!(x instanceof CalcitStructValue))
+        throw new Error(`&struct:assoc-at expected a struct value, got ${x}`);
+    return x.assocAt(idx, field, value);
+}
+export function _$n_struct_$o_with_at(x, ...triples) {
+    if (!(x instanceof CalcitStructValue))
+        throw new Error(`&struct:with-at expected a struct value, got ${x}`);
+    return x.withAt(...triples);
+}
 export function _$n_set_$o_count(x) {
     if (x instanceof CalcitSet)
         return x.len();
@@ -395,7 +409,7 @@ export let _$n__$s_ = (x, y) => {
     return x * y;
 };
 export let _$n_str = (x) => {
-    if (x == null) {
+    if (x === null) {
         return "";
     }
     if (typeof x === "string") {
@@ -607,7 +621,7 @@ export let _$n_enum_$o_validate = function (enumValue, tag) {
     if (!(enumValue instanceof CalcitEnumValue))
         throw new Error("&enum:validate expects an enum value as first argument");
     if (enumValue.enumPrototype == null) {
-        return null;
+        return;
     }
     const proto = assert_enum_tag_args("&enum:validate", enumValue.enumPrototype, tag);
     const tagValue = tag;
@@ -621,7 +635,7 @@ export let _$n_enum_$o_validate = function (enumValue, tag) {
         if (expected !== actual) {
             throw new Error(`enum variant expects ${expected} payload(s), got ${actual} for ${enumValue}`);
         }
-        return null;
+        return;
     }
     throw new Error("Expected variant to be a list");
 };
@@ -783,7 +797,7 @@ export let reset_$x_ = (a, v) => {
     a.listeners.forEach((f) => {
         f(v, prev);
     });
-    return null;
+    return v;
 };
 export let add_watch = (a, k, f) => {
     if (!(a instanceof CalcitRef)) {
@@ -796,29 +810,52 @@ export let add_watch = (a, k, f) => {
         throw new Error("Expected watcher function");
     }
     a.listeners.set(k, f);
-    return null;
 };
 export let remove_watch = (a, k) => {
     a.listeners.delete(k);
-    return null;
 };
+const MAX_RANGE_LENGTH = 4294967295;
 export let range = (n, m, step = 1) => {
-    var result = new CalcitSliceList([]);
-    if (m != null) {
-        var idx = n;
-        while (idx < m) {
-            result = result.append(idx);
-            idx = idx + step;
+    const base = m == null ? 0 : n;
+    const bound = m == null ? n : m;
+    if (!Number.isFinite(base) || !Number.isFinite(bound) || !Number.isFinite(step)) {
+        throw new TypeError("&list:range expected finite numbers for base, bound, and step");
+    }
+    if (base === bound) {
+        return new CalcitSliceList([]);
+    }
+    if (step === 0 || (bound > base && step < 0) || (bound < base && step > 0)) {
+        throw new Error("&list:range cannot construct list with a step of 0 or invalid step direction");
+    }
+    // Avoid overflowing `bound - base` when finite endpoints have opposite signs.
+    const estimatedLength = (base < 0) !== (bound < 0)
+        ? Math.ceil(Math.abs(base) / Math.abs(step) + Math.abs(bound) / Math.abs(step))
+        : Math.ceil((bound - base) / step);
+    if (!Number.isFinite(estimatedLength) || estimatedLength > MAX_RANGE_LENGTH) {
+        throw new Error("&list:range result is too large");
+    }
+    const result = [];
+    if (step > 0) {
+        for (let value = base; value < bound;) {
+            result.push(value);
+            const next = value + step;
+            if (next === value) {
+                throw new Error("&list:range step does not advance the current value");
+            }
+            value = next;
         }
     }
     else {
-        var idx = 0;
-        while (idx < n) {
-            result = result.append(idx);
-            idx = idx + step;
+        for (let value = base; value > bound;) {
+            result.push(value);
+            const next = value + step;
+            if (next === value) {
+                throw new Error("&list:range step does not advance the current value");
+            }
+            value = next;
         }
     }
-    return result;
+    return new CalcitSliceList(result);
 };
 export function _$n_list_$o_empty_$q_(xs) {
     if (xs instanceof CalcitList || xs instanceof CalcitSliceList)
@@ -896,7 +933,6 @@ export let timeout_call = (duration, f) => {
         throw new Error("Expected callback in fn");
     }
     setTimeout(f, duration);
-    return null;
 };
 export let _$n_list_$o_rest = (xs) => {
     if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
@@ -981,10 +1017,9 @@ export let generate_id_$x_ = () => {
 };
 export let _$n_display_stack = () => {
     console.trace();
-    return null;
 };
 export let _$n_list_$o_slice = (xs, from, to) => {
-    if (xs == null) {
+    if (xs === null) {
         return null;
     }
     let size = xs.len();
@@ -1003,7 +1038,7 @@ export let _$n_list_$o_concat = (...lists) => {
     let result = new CalcitSliceList([]);
     for (let idx = 0; idx < lists.length; idx++) {
         let item = lists[idx];
-        if (item == null) {
+        if (item === null) {
             continue;
         }
         if (item instanceof CalcitList || item instanceof CalcitSliceList) {
@@ -1021,7 +1056,7 @@ export let _$n_list_$o_concat = (...lists) => {
     return result;
 };
 export let _$n_list_$o_reverse = (xs) => {
-    if (xs == null) {
+    if (xs === null) {
         return null;
     }
     return xs.reverse();
@@ -1050,12 +1085,12 @@ export let round_$q_ = (a) => {
 };
 export let _$n_str_$o_concat = (a, b) => {
     // Optimize string concatenation by avoiding unnecessary toString calls
-    const aStr = a != null ? toString(a, false) : "";
-    const bStr = b != null ? toString(b, false) : "";
+    const aStr = a !== null ? toString(a, false) : "";
+    const bStr = b !== null ? toString(b, false) : "";
     return aStr + bStr;
 };
 export let sort = (xs, f) => {
-    if (xs == null) {
+    if (xs === null) {
         return null;
     }
     if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
@@ -1068,10 +1103,10 @@ export let floor = (n) => {
     return Math.floor(n);
 };
 export let _$n_merge = (a, b) => {
-    if (a == null) {
+    if (a === null) {
         return b;
     }
-    if (b == null) {
+    if (b === null) {
         return a;
     }
     if (a instanceof CalcitMap || a instanceof CalcitSliceMap) {
@@ -1113,10 +1148,10 @@ export let _$n_merge = (a, b) => {
     throw new Error("Expected map or struct value");
 };
 export let _$n_merge_non_nil = (a, b) => {
-    if (a == null) {
+    if (a === null) {
         return b;
     }
-    if (b == null) {
+    if (b === null) {
         return a;
     }
     if (!(a instanceof CalcitMap || a instanceof CalcitSliceMap)) {
@@ -1174,7 +1209,7 @@ export let _$n_include = (xs, y) => {
     if (!(xs instanceof CalcitSet)) {
         throw new Error("Expected a set");
     }
-    if (y == null) {
+    if (y === null) {
         return xs;
     }
     return xs.include(y);
@@ -1183,7 +1218,7 @@ export let _$n_exclude = (xs, y) => {
     if (!(xs instanceof CalcitSet)) {
         throw new Error("Expected a set");
     }
-    if (y == null) {
+    if (y === null) {
         return xs;
     }
     return xs.exclude(y);
@@ -1302,7 +1337,7 @@ export let aget = (x, name) => {
 export let aset = (x, name, v) => {
     return (x[name] = v);
 };
-export let js_get = aget;
+export let js_get = (x, name) => x[name] ?? null;
 export let js_set = aset;
 /** generates `delete a.b` */
 export let js_delete = (obj, name) => {
@@ -1380,7 +1415,7 @@ export let quit_$x_ = () => {
     }
 };
 export let turn_string = (x) => {
-    if (x == null) {
+    if (x === null) {
         return "";
     }
     if (typeof x === "string") {
@@ -1420,7 +1455,7 @@ export let ends_with_$q_ = (xs, y) => {
     return xs.endsWith(y);
 };
 export let blank_$q_ = (x) => {
-    if (x == null) {
+    if (x === null) {
         return true;
     }
     if (typeof x === "string") {
@@ -1443,7 +1478,7 @@ export let arrayToList = (xs) => {
     return new CalcitSliceList(xs ?? []);
 };
 export let listToArray = (xs) => {
-    if (xs == null) {
+    if (xs === null) {
         return null;
     }
     if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
@@ -1463,7 +1498,7 @@ export let bool_$q_ = (x) => {
     return typeof x === "boolean";
 };
 export let nil_$q_ = (x) => {
-    return x == null;
+    return x === null;
 };
 export let tag_$q_ = (x) => {
     return x instanceof CalcitTag;
@@ -1540,8 +1575,10 @@ export let parse_cirru_edn = (code, options) => {
     }
 };
 const typed_edn_kind = (value) => {
-    if (value == null)
+    if (value === null)
         return "nil";
+    if (value === undefined)
+        return "unit";
     if (typeof value === "boolean")
         return "bool";
     if (typeof value === "number")
@@ -1583,10 +1620,14 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
     if (node == null)
         typed_edn_error(path, `invalid data shape node #${nodeId}`);
     switch (node.kind) {
-        case "unit":
-            if (input == null)
+        case "nil":
+            if (input === null)
                 return null;
-            return typed_edn_error(path, `expected nil, got ${typed_edn_kind(input)}`);
+            return typed_edn_error(path, `expected Nil, got ${typed_edn_kind(input)}`);
+        case "unit":
+            if (input === undefined)
+                return input;
+            return typed_edn_error(path, `expected Unit, got ${typed_edn_kind(input)}`);
         case "bool":
             if (typeof input === "boolean")
                 return input;
@@ -1616,7 +1657,7 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
                 return input;
             return typed_edn_error(path, `expected cirru-quote, got ${typed_edn_kind(input)}`);
         case "optional":
-            return input == null ? null : decode_typed_edn_node(graph, node.inner, input, path, depth + 1);
+            return input === null ? null : decode_typed_edn_node(graph, node.inner, input, path, depth + 1);
         case "list": {
             if (!(input instanceof CalcitList || input instanceof CalcitSliceList)) {
                 return typed_edn_error(path, `expected list, got ${typed_edn_kind(input)}`);
@@ -1681,8 +1722,8 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
                 const idx = actualNames.indexOf(name);
                 decodedFields.set(name, decode_typed_edn_node(graph, fieldNode, input.values[idx], `${path}.${name}`, depth + 1));
             });
-            // Native declarations use lexical field order while the JS runtime keeps
-            // its interned-tag order. Re-align values to the nominal JS declaration.
+            // Re-align by name so values produced by older runtimes or external data
+            // still adopt the current nominal declaration's canonical field layout.
             if (decodedFields.size !== node.nominal.fields.length) {
                 return typed_edn_error(path, `struct :${node.nominal.name.value} decoder fields do not match its nominal declaration`);
             }
@@ -1723,8 +1764,8 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
 export let parse_cirru_edn_as = (code, graph) => {
     if (typeof code !== "string")
         throw new Error(`parse-cirru-edn-as expected a string, got ${typed_edn_kind(code)}`);
-    if (graph.version !== 1)
-        throw new Error(`parse-cirru-edn-as expected data shape ABI version 1, got ${graph.version}`);
+    if (graph.version !== 2)
+        throw new Error(`parse-cirru-edn-as expected data shape ABI version 2, got ${graph.version}`);
     if (typeof graph.fingerprint !== "string" || graph.fingerprint.length === 0) {
         throw new Error("parse-cirru-edn-as expected a non-empty data shape fingerprint");
     }
@@ -1842,7 +1883,7 @@ const decode_runtime_map_node = (graph, nodeId, input, path, depth) => {
             return new CalcitSliceMap(entries.flat());
         }
         case "optional":
-            return input == null ? null : decode_runtime_map_node(graph, node.inner, input, path, depth + 1);
+            return input === null ? null : decode_runtime_map_node(graph, node.inner, input, path, depth + 1);
         case "ref":
             if (!(input instanceof CalcitRef))
                 return map_decode_error(path, `expected atom, got ${typed_edn_kind(input)}`);
@@ -1872,8 +1913,8 @@ const decode_runtime_map_node = (graph, nodeId, input, path, depth) => {
     }
 };
 export let decode_map_as = (value, graph) => {
-    if (graph.version !== 1)
-        throw new Error(`decode-map-as expected data shape ABI version 1, got ${graph.version}`);
+    if (graph.version !== 2)
+        throw new Error(`decode-map-as expected data shape ABI version 2, got ${graph.version}`);
     if (typeof graph.fingerprint !== "string" || graph.fingerprint.length === 0) {
         throw new Error("decode-map-as expected a non-empty data shape fingerprint");
     }
@@ -1915,7 +1956,7 @@ const cirru_quote_to_json = (value) => {
     throw new Error(`Unsupported cirru quote node: ${value}`);
 };
 const calcit_to_json = (value) => {
-    if (value == null)
+    if (value === null)
         return null;
     if (typeof value === "string")
         return value;
@@ -1977,9 +2018,12 @@ export let json_pretty = function (value) {
     return JSON.stringify(calcit_to_json(value), null, 2);
 };
 export let format_to_lisp = (x) => {
-    if (x == null) {
+    if (x === null) {
         return "nil";
     }
+    else if (x === undefined) {
+        return "&unit";
+    }
     else if (x instanceof CalcitSymbol) {
         return x.value;
     }
@@ -2007,9 +2051,12 @@ export let format_to_cirru = (x) => {
     return writeCirruCode([xs], { useInline: false });
 };
 export let transform_code_to_cirru = (x) => {
-    if (x == null) {
+    if (x === null) {
         return "nil";
     }
+    else if (x === undefined) {
+        return "&unit";
+    }
     else if (x instanceof CalcitSymbol) {
         return x.value;
     }

package/lib/custom-formatter.mjs

@@ -10,9 +10,12 @@ import { CalcitSet } from "./js-set.mjs";
 import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitCirruQuote } from "./js-cirru.mjs";
 let embedObject = (x) => {
-    if (x == null) {
+    if (x === null) {
         return null;
     }
+    if (x === undefined) {
+        return span({ whiteSpace: "pre", color: hsl(240, 70, 50) }, "&unit");
+    }
     if (typeof x === "string") {
         return span({ whiteSpace: "pre", color: hsl(120, 70, 50), maxWidth: "100vw" }, `|${x}`);
     }
@@ -61,6 +64,12 @@ let td = (style, ...children) => {
 };
 /** handle null value in nested data */
 let saveString = (v) => {
+    if (v === null) {
+        return "nil";
+    }
+    if (v === undefined) {
+        return "&unit";
+    }
     if (typeof v === "string") {
         if (v.match(/[\s\"\n\t\,]/)) {
             return `"|${v}"`;
@@ -69,11 +78,11 @@ let saveString = (v) => {
             return `|${v}`;
         }
     }
-    else if (v != null && v.toString) {
+    else if (v.toString) {
         return v.toString();
     }
     else {
-        return "nil";
+        return String(v);
     }
 };
 export let load_console_formatter_$x_ = () => {

package/lib/js-cirru.mjs

@@ -4,7 +4,7 @@ import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
-import { CalcitTag, CalcitSymbol, CalcitRecur, newTag } from "./calcit-data.mjs";
+import { CalcitTag, CalcitSymbol, CalcitRecur, newTag, compareTagNames } from "./calcit-data.mjs";
 import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitEnumDef } from "./js-enum-def.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
@@ -79,9 +79,12 @@ export let format_cirru_one_liner = (data) => {
 };
 /** better use string version of Cirru EDN in future */
 export let to_cirru_edn = (x) => {
-    if (x == null) {
+    if (x === null) {
         return "nil";
     }
+    if (x === undefined) {
+        throw new Error("Cirru EDN cannot encode &unit");
+    }
     if (typeof x === "string") {
         return `|${x}`;
     }
@@ -364,9 +367,7 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
                     throw new Error(`Expected field pairs for struct, got: ${pair}`);
                 }
             });
-            entries.sort((a, b) => {
-                return a[0].cmp(b[0]);
-            });
+            entries.sort((a, b) => compareTagNames(a[0], b[0]));
             let fields = [];
             let values = [];
             for (let idx = 0; idx < entries.length; idx++) {

package/lib/js-impl.mjs

@@ -1,4 +1,4 @@
-import { castTag, findInFields, toString } from "./calcit-data.mjs";
+import { canonicalizeTagPairs, castTag, findInFields, toString } from "./calcit-data.mjs";
 const CALCIT_IMPL_BRAND = Symbol.for("@calcit/procs/CalcitImpl");
 export class CalcitImpl {
     static [Symbol.hasInstance](value) {
@@ -29,10 +29,11 @@ export class CalcitImpl {
         // optimized dependencies. A global, non-enumerable brand keeps impl values
         // recognizable across those otherwise distinct module instances.
         Object.defineProperty(this, CALCIT_IMPL_BRAND, { value: true });
+        const [canonicalFields, canonicalValues] = canonicalizeTagPairs(fields, values, "CalcitImpl");
         this.name = name;
         this.origin = origin;
-        this.fields = fields;
-        this.values = values;
+        this.fields = canonicalFields;
+        this.values = canonicalValues;
         this.cachedHash = null;
     }
     get(k) {

package/lib/js-primes.d.mts

@@ -10,6 +10,6 @@ import { CalcitSet as CalcitSet } from "./js-set.mjs";
 import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitCirruQuote } from "./js-cirru.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
-export type CalcitValue = string | number | boolean | CalcitMap | CalcitSliceMap | CalcitList | CalcitSliceList | CalcitSet | CalcitTag | CalcitSymbol | CalcitRef | CalcitEnumValue | CalcitFn | CalcitRecur | CalcitStructValue | CalcitImpl | CalcitTrait | CalcitStructDef | CalcitEnumDef | CalcitCirruQuote | null;
+export type CalcitValue = string | number | boolean | CalcitMap | CalcitSliceMap | CalcitList | CalcitSliceList | CalcitSet | CalcitTag | CalcitSymbol | CalcitRef | CalcitEnumValue | CalcitFn | CalcitRecur | CalcitStructValue | CalcitImpl | CalcitTrait | CalcitStructDef | CalcitEnumDef | CalcitCirruQuote | undefined | null;
 export declare let isLiteral: (x: CalcitValue) => boolean;
 export declare let _$n_compare: (a: CalcitValue, b: CalcitValue) => number;

package/lib/js-primes.mjs

@@ -27,28 +27,31 @@ export let isLiteral = (x) => {
 var PseudoTypeIndex;
 (function (PseudoTypeIndex) {
     PseudoTypeIndex[PseudoTypeIndex["nil"] = 0] = "nil";
-    PseudoTypeIndex[PseudoTypeIndex["bool"] = 1] = "bool";
-    PseudoTypeIndex[PseudoTypeIndex["number"] = 2] = "number";
-    PseudoTypeIndex[PseudoTypeIndex["symbol"] = 3] = "symbol";
-    PseudoTypeIndex[PseudoTypeIndex["tag"] = 4] = "tag";
-    PseudoTypeIndex[PseudoTypeIndex["string"] = 5] = "string";
-    PseudoTypeIndex[PseudoTypeIndex["ref"] = 6] = "ref";
-    PseudoTypeIndex[PseudoTypeIndex["enum_value"] = 7] = "enum_value";
-    PseudoTypeIndex[PseudoTypeIndex["recur"] = 8] = "recur";
-    PseudoTypeIndex[PseudoTypeIndex["list"] = 9] = "list";
-    PseudoTypeIndex[PseudoTypeIndex["set"] = 10] = "set";
-    PseudoTypeIndex[PseudoTypeIndex["map"] = 11] = "map";
-    PseudoTypeIndex[PseudoTypeIndex["struct_value"] = 12] = "struct_value";
-    PseudoTypeIndex[PseudoTypeIndex["impl"] = 13] = "impl";
-    PseudoTypeIndex[PseudoTypeIndex["struct_def"] = 14] = "struct_def";
-    PseudoTypeIndex[PseudoTypeIndex["enum_def"] = 15] = "enum_def";
-    PseudoTypeIndex[PseudoTypeIndex["fn"] = 16] = "fn";
-    PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 17] = "cirru_quote";
+    PseudoTypeIndex[PseudoTypeIndex["unit"] = 1] = "unit";
+    PseudoTypeIndex[PseudoTypeIndex["bool"] = 2] = "bool";
+    PseudoTypeIndex[PseudoTypeIndex["number"] = 3] = "number";
+    PseudoTypeIndex[PseudoTypeIndex["symbol"] = 4] = "symbol";
+    PseudoTypeIndex[PseudoTypeIndex["tag"] = 5] = "tag";
+    PseudoTypeIndex[PseudoTypeIndex["string"] = 6] = "string";
+    PseudoTypeIndex[PseudoTypeIndex["ref"] = 7] = "ref";
+    PseudoTypeIndex[PseudoTypeIndex["enum_value"] = 8] = "enum_value";
+    PseudoTypeIndex[PseudoTypeIndex["recur"] = 9] = "recur";
+    PseudoTypeIndex[PseudoTypeIndex["list"] = 10] = "list";
+    PseudoTypeIndex[PseudoTypeIndex["set"] = 11] = "set";
+    PseudoTypeIndex[PseudoTypeIndex["map"] = 12] = "map";
+    PseudoTypeIndex[PseudoTypeIndex["struct_value"] = 13] = "struct_value";
+    PseudoTypeIndex[PseudoTypeIndex["impl"] = 14] = "impl";
+    PseudoTypeIndex[PseudoTypeIndex["struct_def"] = 15] = "struct_def";
+    PseudoTypeIndex[PseudoTypeIndex["enum_def"] = 16] = "enum_def";
+    PseudoTypeIndex[PseudoTypeIndex["fn"] = 17] = "fn";
+    PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 18] = "cirru_quote";
 })(PseudoTypeIndex || (PseudoTypeIndex = {}));
 let typeAsInt = (x) => {
     // based on order used in Ord trait
-    if (x == null)
+    if (x === null)
         return PseudoTypeIndex.nil;
+    if (x === undefined)
+        return PseudoTypeIndex.unit;
     let t = typeof x;
     if (t === "boolean")
         return PseudoTypeIndex.bool;
@@ -106,6 +109,7 @@ export let _$n_compare = (a, b) => {
     if (ta === tb) {
         switch (ta) {
             case PseudoTypeIndex.nil:
+            case PseudoTypeIndex.unit:
                 return 0;
             case PseudoTypeIndex.bool:
                 return rawCompare(a, b);

package/lib/js-struct-def.mjs

@@ -1,13 +1,11 @@
-import { toString } from "./calcit-data.mjs";
+import { canonicalizeTagPairs, toString } from "./calcit-data.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 export class CalcitStructDef {
     constructor(name, fields, fieldTypes, impls = []) {
-        if (fields.length !== fieldTypes.length) {
-            throw new Error("CalcitStructDef: fields and fieldTypes length mismatch");
-        }
+        const [canonicalFields, canonicalTypes] = canonicalizeTagPairs(fields, fieldTypes, "CalcitStructDef");
         this.name = name;
-        this.fields = fields;
-        this.fieldTypes = fieldTypes;
+        this.fields = canonicalFields;
+        this.fieldTypes = canonicalTypes;
         this.impls = impls;
         this.cachedHash = null;
     }

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

@@ -14,6 +14,10 @@ export declare class CalcitStructValue {
     getRequired(k: CalcitValue): CalcitValue;
     getOrNil(k: CalcitValue): CalcitValue;
     assoc(k: CalcitValue, v: CalcitValue): CalcitStructValue;
+    nthAt(index: CalcitValue, field: CalcitValue): CalcitValue;
+    assocAt(index: CalcitValue, field: CalcitValue, value: CalcitValue): CalcitStructValue;
+    withAt(...triples: CalcitValue[]): CalcitStructValue;
+    private assertFieldAt;
     /** return -1 for missing */
     findIndex(k: CalcitValue): number;
     contains(k: CalcitValue): boolean;
@@ -23,7 +27,7 @@ export declare class CalcitStructValue {
 export declare let new_struct_value: (name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
 export declare let new_impl_struct_value: (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
 /** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
- *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+ *  Fields use the same lexical layout as named structs. The record name is "_". */
 export declare let _$q__$M_: (...xs: Array<CalcitValue>) => CalcitValue;
 export declare let fieldsEqual: (xs: Array<CalcitTag>, ys: Array<CalcitTag>) => boolean;
 export declare let _$n__PCT__$M_: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;