@calcit/procs 0.13.43 → 0.13.44

package/lib/calcit-data.mjs

@@ -105,6 +105,51 @@ export let getStringName = (x) => {
     }
     throw new Error("Cannot get string as name");
 };
+/** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
+export function compareTagNames(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);
+        if (xCode < yCode)
+            return -1;
+        if (xCode > yCode)
+            return 1;
+        xIdx += xCode > 0xffff ? 2 : 1;
+        yIdx += yCode > 0xffff ? 2 : 1;
+    }
+    if (xIdx < x.value.length)
+        return 1;
+    if (yIdx < y.value.length)
+        return -1;
+    return 0;
+}
+export function tagNamesAreCanonical(fields) {
+    for (let idx = 1; idx < fields.length; idx++) {
+        if (compareTagNames(fields[idx - 1], fields[idx]) >= 0)
+            return false;
+    }
+    return true;
+}
+export function canonicalizeTagPairs(fields, values, context) {
+    if (fields.length !== values.length) {
+        throw new Error(`${context}: fields and values length mismatch`);
+    }
+    if (tagNamesAreCanonical(fields))
+        return [fields, values];
+    const pairs = fields.map((field, idx) => [field, values[idx]]);
+    pairs.sort((a, b) => compareTagNames(a[0], b[0]));
+    for (let idx = 1; idx < pairs.length; idx++) {
+        if (pairs[idx - 1][0].value === pairs[idx][0].value) {
+            throw new Error(`${context}: duplicated field :${pairs[idx][0].value}`);
+        }
+    }
+    return [
+        pairs.map(([field]) => field),
+        pairs.map(([, value]) => value),
+    ];
+}
 /** returns -1 when not found */
 export function findInFields(xs, y) {
     let low = 0;
@@ -112,10 +157,11 @@ export function findInFields(xs, y) {
     while (low <= high) {
         const mid = Math.floor((low + high) / 2);
         const midVal = xs[mid];
-        if (midVal.idx < y.idx) {
+        const ordering = compareTagNames(midVal, y);
+        if (ordering < 0) {
             low = mid + 1;
         }
-        else if (midVal.idx > y.idx) {
+        else if (ordering > 0) {
             high = mid - 1;
         }
         else {
@@ -156,6 +202,7 @@ export let castTag = (x) => {
 };
 export var refsRegistry = new Map();
 let defaultHash_nil = valueHash("nil:");
+let defaultHash_unit = valueHash("unit:");
 let defaultHash_number = valueHash("number:");
 let defaultHash_string = valueHash("string:");
 let defaultHash_tag = valueHash("tag:");
@@ -177,9 +224,11 @@ let defaultHash_unknown = valueHash("unknown:");
 let fnHashCounter = 0;
 let jsObjectHashCounter = 0;
 export let hashFunction = (x) => {
-    if (x == null) {
+    if (x === null) {
         return defaultHash_nil;
     }
+    if (x === undefined)
+        return defaultHash_unit;
     if (typeof x === "number") {
         return mergeValueHash(defaultHash_number, x);
     }
@@ -367,9 +416,11 @@ let hashCirru = (base, x) => {
 // Dirty code to change ternary-tree behavior
 overwriteHashGenerator(hashFunction);
 export let toString = (x, escaped, disableJsDataWarning = false) => {
-    if (x == null) {
+    if (x === null) {
         return "nil";
     }
+    if (x === undefined)
+        return "&unit";
     if (typeof x === "string") {
         if (escaped) {
             // turn to visual string representation
@@ -473,9 +524,11 @@ export let to_js_data = (x, options) => {
     return to_js_data_inner(x, addColon);
 };
 let to_js_data_inner = (x, addColon) => {
-    if (x == null) {
+    if (x === null) {
         return null;
     }
+    if (x === undefined)
+        return undefined;
     if (x === true || x === false) {
         return x;
     }
@@ -560,10 +613,7 @@ export let _$n__$e_ = (x, y) => {
     if (x === y) {
         return true;
     }
-    if (x == null) {
-        if (y == null) {
-            return true;
-        }
+    if (x === null) {
         return false;
     }
     let tx = typeof x;

package/lib/calcit.procs.d.mts

@@ -18,7 +18,13 @@ export declare const calcit_package_json: {
         "test-fail": string;
         "test-snippets": string;
         "check-js-runtime": string;
+        "check-literal-paths": string;
+        "check-typed-method-rem": string;
         "bench-recur-smoke": string;
+        "bench-enum-match": string;
+        "bench-literal-paths": string;
+        "bench-typed-method-rem": string;
+        "bench-struct-index": string;
         "check-smooth": string;
         "check-all": string;
         "check-agent-interface": string;
@@ -87,7 +93,9 @@ export declare function _$n_str_$o_count(x: CalcitValue): number;
 export declare function _$n_map_$o_count(x: CalcitValue): number;
 export declare function _$n_struct_$o_count(x: CalcitValue): number;
 export declare function _$n_struct_$o_field_tag(x: CalcitValue, idx: CalcitValue): CalcitTag;
-export declare function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue, field?: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_assoc_at(x: CalcitValue, idx: CalcitValue, field: CalcitValue, value: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_with_at(x: CalcitValue, ...triples: CalcitValue[]): CalcitValue;
 export declare function _$n_set_$o_count(x: CalcitValue): number;
 export declare let _$L_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _SQUO_: (...xs: CalcitValue[]) => CalcitSliceList;
@@ -119,7 +127,7 @@ export declare let _$n_enum_$o_definition: (x: CalcitEnumValue) => CalcitEnumDef
 export declare let _$n_enum_def_$o_has_variant_$q_: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
 export declare let _$n_enum_def_$o_has_variant: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
 export declare let _$n_enum_def_$o_variant_arity: (enumPrototype: CalcitValue, variantTag: CalcitTag) => number;
-export declare let _$n_enum_$o_validate: (enumValue: CalcitValue, tag: CalcitValue) => CalcitValue;
+export declare let _$n_enum_$o_validate: (enumValue: CalcitValue, tag: CalcitValue) => void;
 export declare let _$n_struct_$o_get: (xs: CalcitValue, k: CalcitTag) => CalcitValue;
 export declare let _$n_list_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitList;
 export declare let _$n_enum_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitEnumValue;
@@ -136,9 +144,9 @@ export declare let _$n_list_$o_assoc_before: (xs: CalcitList | CalcitSliceList,
 export declare let _$n_list_$o_assoc_after: (xs: CalcitSliceList, k: number, v: CalcitValue) => CalcitList | CalcitSliceList;
 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) => null;
-export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => null;
-export declare let remove_watch: (a: CalcitRef, k: CalcitTag) => null;
+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 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;
 export declare function _$n_str_$o_empty_$q_(xs: CalcitValue): boolean;
@@ -149,7 +157,7 @@ export declare let _$n_list_$o_last: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_str_$o_first: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_map_$o_destruct: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_set_$o_destruct: (xs: CalcitValue) => CalcitValue;
-export declare let timeout_call: (duration: number, f: CalcitFn) => null;
+export declare let timeout_call: (duration: number, f: CalcitFn) => void;
 export declare let _$n_list_$o_rest: (xs: CalcitValue) => CalcitList | CalcitSliceList;
 export declare let _$n_str_$o_rest: (xs: CalcitValue) => CalcitValue;
 export declare let recur: (...xs: CalcitValue[]) => CalcitRecur;
@@ -162,7 +170,7 @@ export declare let butlast: (xs: CalcitValue) => CalcitList | CalcitSliceList |
 export declare let initCrTernary: (x: string) => CalcitValue;
 export declare let _SHA__$M_: (...xs: CalcitValue[]) => CalcitValue;
 export declare let generate_id_$x_: () => string;
-export declare let _$n_display_stack: () => null;
+export declare let _$n_display_stack: () => void;
 export declare let _$n_list_$o_slice: (xs: CalcitList, from: number, to: number) => CalcitSliceList | CalcitList;
 export declare let _$n_list_$o_concat: (...lists: (CalcitList | CalcitSliceList)[]) => CalcitList | CalcitSliceList;
 export declare let _$n_list_$o_reverse: (xs: CalcitList) => CalcitList;
@@ -247,7 +255,7 @@ export declare let parse_cirru: (code: string) => CalcitCirruQuote;
 export declare let parse_cirru_list: (code: string) => CalcitList;
 export declare let parse_cirru_edn: (code: string, options: CalcitValue) => CalcitValue;
 type DataShapeNode = {
-    kind: "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" | "dynamic";
+    kind: "nil" | "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" | "dynamic";
 } | {
     kind: "optional" | "list" | "set" | "ref";
     inner: number;

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,11 +810,9 @@ 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) => {
@@ -921,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) {
@@ -1006,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();
@@ -1028,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) {
@@ -1046,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();
@@ -1075,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) {
@@ -1093,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) {
@@ -1138,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)) {
@@ -1199,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);
@@ -1208,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);
@@ -1327,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) => {
@@ -1405,7 +1415,7 @@ export let quit_$x_ = () => {
     }
 };
 export let turn_string = (x) => {
-    if (x == null) {
+    if (x === null) {
         return "";
     }
     if (typeof x === "string") {
@@ -1445,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") {
@@ -1468,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) {
@@ -1488,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;
@@ -1565,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")
@@ -1608,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;
@@ -1641,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)}`);
@@ -1706,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`);
             }
@@ -1748,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");
     }
@@ -1867,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)}`);
@@ -1897,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");
     }
@@ -1940,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;
@@ -2002,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;
     }
@@ -2032,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;