@calcit/procs 0.13.42 → 0.13.44

package/ts-src/calcit.procs.mts

@@ -17,6 +17,7 @@ import {
   refsRegistry,
   toString,
   getStringName,
+  compareTagNames,
   _$n__$e_,
   hashFunction,
 } from "./calcit-data.mjs";
@@ -71,9 +72,10 @@ export let type_of = (x: any): CalcitTag => {
   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");
   }
@@ -252,7 +254,7 @@ export let defstruct = (name: CalcitValue, ...entries: CalcitValue[]): CalcitStr
     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()}`);
@@ -279,7 +281,7 @@ export let defenum = (name: CalcitValue, ...variants: CalcitValue[]): CalcitEnum
     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()}`);
@@ -324,7 +326,7 @@ export let _$n_impl_$o__$o_new = (name: CalcitValue, ...pairs: CalcitValue[]): C
     }
     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()}`);
@@ -391,13 +393,24 @@ export function _$n_struct_$o_field_tag(x: CalcitValue, idx: CalcitValue): Calci
   return x.fields[i];
 }
 
-export function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue): CalcitValue {
+export function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue, field?: CalcitValue): CalcitValue {
   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 as number;
   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: CalcitValue, idx: CalcitValue, field: CalcitValue, value: CalcitValue): CalcitValue {
+  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: CalcitValue, ...triples: CalcitValue[]): CalcitValue {
+  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: CalcitValue): number {
   if (x instanceof CalcitSet) return x.len();
@@ -449,7 +462,7 @@ export let _$n__$s_ = (x: number, y: number): number => {
 };
 
 export let _$n_str = (x: CalcitValue): string => {
-  if (x == null) {
+  if (x === null) {
     return "";
   }
   if (typeof x === "string") {
@@ -675,11 +688,11 @@ export let _$n_enum_def_$o_variant_arity = function (enumPrototype: CalcitValue,
   throw new Error("Expected variant to be a list");
 };
 
-export let _$n_enum_$o_validate = function (enumValue: CalcitValue, tag: CalcitValue): CalcitValue {
+export let _$n_enum_$o_validate = function (enumValue: CalcitValue, tag: CalcitValue): void {
   if (arguments.length !== 2) throw new Error("&enum:validate takes 2 arguments");
   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 as CalcitValue, tag as CalcitTag);
@@ -696,7 +709,7 @@ export let _$n_enum_$o_validate = function (enumValue: CalcitValue, tag: CalcitV
     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");
@@ -858,7 +871,7 @@ export let _$n_map_$o_dissoc = function (xs: CalcitValue, ...args: CalcitValue[]
   throw new Error("`dissoc` expected a map");
 };
 
-export let reset_$x_ = (a: CalcitRef, v: CalcitValue): null => {
+export let reset_$x_ = (a: CalcitRef, v: CalcitValue): CalcitValue => {
   if (!(a instanceof CalcitRef)) {
     throw new Error("Expected ref for reset!");
   }
@@ -867,10 +880,10 @@ export let reset_$x_ = (a: CalcitRef, v: CalcitValue): null => {
   a.listeners.forEach((f) => {
     f(v, prev);
   });
-  return null;
+  return v;
 };
 
-export let add_watch = (a: CalcitRef, k: CalcitTag, f: CalcitFn): null => {
+export let add_watch = (a: CalcitRef, k: CalcitTag, f: CalcitFn): void => {
   if (!(a instanceof CalcitRef)) {
     throw new Error("Expected ref for add-watch!");
   }
@@ -881,30 +894,57 @@ export let add_watch = (a: CalcitRef, k: CalcitTag, f: CalcitFn): null => {
     throw new Error("Expected watcher function");
   }
   a.listeners.set(k, f);
-  return null;
 };
 
-export let remove_watch = (a: CalcitRef, k: CalcitTag): null => {
+export let remove_watch = (a: CalcitRef, k: CalcitTag): void => {
   a.listeners.delete(k);
-  return null;
 };
 
-export let range = (n: number, m: number, step: number = 1): CalcitSliceList | CalcitList => {
-  var result: CalcitList | CalcitSliceList = new CalcitSliceList([]);
-  if (m != null) {
-    var idx = n;
-    while (idx < m) {
-      result = result.append(idx);
-      idx = idx + step;
+const MAX_RANGE_LENGTH = 0xffff_ffff;
+
+export let range = (n: number, m?: number, step: number = 1): CalcitSliceList => {
+  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: Array<CalcitValue> = [];
+  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: CalcitValue): boolean {
@@ -977,7 +1017,7 @@ export let _$n_set_$o_destruct = (xs: CalcitValue): CalcitValue => {
   throw new Error("Expect a set");
 };
 
-export let timeout_call = (duration: number, f: CalcitFn): null => {
+export let timeout_call = (duration: number, f: CalcitFn): void => {
   if (typeof duration !== "number") {
     throw new Error("Expected duration in number");
   }
@@ -985,7 +1025,6 @@ export let timeout_call = (duration: number, f: CalcitFn): null => {
     throw new Error("Expected callback in fn");
   }
   setTimeout(f, duration);
-  return null;
 };
 
 export let _$n_list_$o_rest = (xs: CalcitValue): CalcitList | CalcitSliceList => {
@@ -1082,13 +1121,12 @@ export let generate_id_$x_ = (): string => {
   return `gen_id_${idCounter}_${time}`;
 };
 
-export let _$n_display_stack = (): null => {
+export let _$n_display_stack = (): void => {
   console.trace();
-  return null;
 };
 
 export let _$n_list_$o_slice = (xs: CalcitList, from: number, to: number): CalcitSliceList | CalcitList => {
-  if (xs == null) {
+  if (xs === null) {
     return null;
   }
   let size = xs.len();
@@ -1106,7 +1144,7 @@ export let _$n_list_$o_concat = (...lists: (CalcitList | CalcitSliceList)[]): Ca
   let result: CalcitSliceList | CalcitList = 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) {
@@ -1123,7 +1161,7 @@ export let _$n_list_$o_concat = (...lists: (CalcitList | CalcitSliceList)[]): Ca
 };
 
 export let _$n_list_$o_reverse = (xs: CalcitList): CalcitList => {
-  if (xs == null) {
+  if (xs === null) {
     return null;
   }
   return xs.reverse();
@@ -1154,12 +1192,12 @@ export let round_$q_ = (a: number) => {
 };
 export let _$n_str_$o_concat = (a: string, b: string) => {
   // 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: CalcitList | CalcitSliceList, f: CalcitFn): CalcitSliceList => {
-  if (xs == null) {
+  if (xs === null) {
     return null;
   }
   if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
@@ -1174,10 +1212,10 @@ export let floor = (n: number): number => {
 };
 
 export let _$n_merge = (a: CalcitValue, b: CalcitMap | CalcitSliceMap): CalcitValue => {
-  if (a == null) {
+  if (a === null) {
     return b;
   }
-  if (b == null) {
+  if (b === null) {
     return a;
   }
   if (a instanceof CalcitMap || a instanceof CalcitSliceMap) {
@@ -1217,10 +1255,10 @@ export let _$n_merge = (a: CalcitValue, b: CalcitMap | CalcitSliceMap): CalcitVa
 };
 
 export let _$n_merge_non_nil = (a: CalcitMap | CalcitSliceMap, b: CalcitMap | CalcitSliceMap): CalcitMap | CalcitSliceMap => {
-  if (a == null) {
+  if (a === null) {
     return b;
   }
-  if (b == null) {
+  if (b === null) {
     return a;
   }
   if (!(a instanceof CalcitMap || a instanceof CalcitSliceMap)) {
@@ -1282,7 +1320,7 @@ export let _$n_include = (xs: CalcitSet, y: CalcitValue): CalcitSet => {
   if (!(xs instanceof CalcitSet)) {
     throw new Error("Expected a set");
   }
-  if (y == null) {
+  if (y === null) {
     return xs;
   }
   return xs.include(y);
@@ -1292,7 +1330,7 @@ export let _$n_exclude = (xs: CalcitSet, y: CalcitValue): CalcitSet => {
   if (!(xs instanceof CalcitSet)) {
     throw new Error("Expected a set");
   }
-  if (y == null) {
+  if (y === null) {
     return xs;
   }
   return xs.exclude(y);
@@ -1423,7 +1461,7 @@ export let aget = (x: any, name: string): any => {
 export let aset = (x: any, name: string, v: any): any => {
   return (x[name] = v);
 };
-export let js_get = aget;
+export let js_get = (x: any, name: string): any => x[name] ?? null;
 export let js_set = aset;
 /** generates `delete a.b` */
 export let js_delete = (obj: any, name: string): any => {
@@ -1508,7 +1546,7 @@ export let quit_$x_ = (): void => {
 };
 
 export let turn_string = (x: CalcitValue): string => {
-  if (x == null) {
+  if (x === null) {
     return "";
   }
   if (typeof x === "string") {
@@ -1551,7 +1589,7 @@ export let ends_with_$q_ = (xs: string, y: string): boolean => {
 };
 
 export let blank_$q_ = (x: string): boolean => {
-  if (x == null) {
+  if (x === null) {
     return true;
   }
   if (typeof x === "string") {
@@ -1576,7 +1614,7 @@ export let arrayToList = (xs: Array<CalcitValue>): CalcitSliceList => {
 };
 
 export let listToArray = (xs: CalcitList | CalcitSliceList): Array<CalcitValue> => {
-  if (xs == null) {
+  if (xs === null) {
     return null;
   }
   if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
@@ -1596,7 +1634,7 @@ export let bool_$q_ = (x: CalcitValue): boolean => {
   return typeof x === "boolean";
 };
 export let nil_$q_ = (x: CalcitValue): boolean => {
-  return x == null;
+  return x === null;
 };
 export let tag_$q_ = (x: CalcitValue): boolean => {
   return x instanceof CalcitTag;
@@ -1676,7 +1714,7 @@ export let parse_cirru_edn = (code: string, options: 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 }
   | { kind: "map"; key: number; value: number }
   | { kind: "map-option"; nominal: CalcitEnumDef; inner: number }
@@ -1691,7 +1729,8 @@ type DataShapeGraph = {
 };
 
 const typed_edn_kind = (value: any): string => {
-  if (value == null) return "nil";
+  if (value === null) return "nil";
+  if (value === undefined) return "unit";
   if (typeof value === "boolean") return "bool";
   if (typeof value === "number") return "number";
   if (typeof value === "string") return "string";
@@ -1722,9 +1761,12 @@ const decode_typed_edn_node = (graph: DataShapeGraph, nodeId: number, input: any
   if (node == null) typed_edn_error(path, `invalid data shape node #${nodeId}`);
 
   switch (node.kind) {
+    case "nil":
+      if (input === null) return null;
+      return typed_edn_error(path, `expected Nil, got ${typed_edn_kind(input)}`);
     case "unit":
-      if (input == null) return null;
-      return typed_edn_error(path, `expected nil, got ${typed_edn_kind(input)}`);
+      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;
       return typed_edn_error(path, `expected bool, got ${typed_edn_kind(input)}`);
@@ -1747,7 +1789,7 @@ const decode_typed_edn_node = (graph: DataShapeGraph, nodeId: number, input: any
       if (input instanceof CalcitCirruQuote) 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)}`);
@@ -1816,8 +1858,8 @@ const decode_typed_edn_node = (graph: DataShapeGraph, nodeId: number, input: any
         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`);
       }
@@ -1863,7 +1905,7 @@ const decode_typed_edn_node = (graph: DataShapeGraph, nodeId: number, input: any
 
 export let parse_cirru_edn_as = (code: string, graph: DataShapeGraph): CalcitValue => {
   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");
   }
@@ -1974,7 +2016,7 @@ const decode_runtime_map_node = (graph: DataShapeGraph, nodeId: number, input: a
       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)}`);
       return atom(decode_runtime_map_node(graph, node.inner, input.value, `${path}.value`, depth + 1));
@@ -2007,7 +2049,7 @@ const decode_runtime_map_node = (graph: DataShapeGraph, nodeId: number, input: a
 };
 
 export let decode_map_as = (value: CalcitValue, graph: DataShapeGraph): CalcitValue => {
-  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");
   }
@@ -2045,7 +2087,7 @@ const cirru_quote_to_json = (value: ICirruNode): any => {
 };
 
 const calcit_to_json = (value: CalcitValue): any => {
-  if (value == null) return null;
+  if (value === null) return null;
   if (typeof value === "string") return value;
   if (typeof value === "number") {
     if (Number.isFinite(value)) return value;
@@ -2102,8 +2144,10 @@ export let json_pretty = function (value: CalcitValue): string {
 };
 
 export let format_to_lisp = (x: CalcitValue): string => {
-  if (x == null) {
+  if (x === null) {
     return "nil";
+  } else if (x === undefined) {
+    return "&unit";
   } else if (x instanceof CalcitSymbol) {
     return x.value;
   } else if (x instanceof CalcitList || x instanceof CalcitSliceList) {
@@ -2130,8 +2174,10 @@ export let format_to_cirru = (x: CalcitValue): string => {
 };
 
 export let transform_code_to_cirru = (x: CalcitValue): ICirruNode => {
-  if (x == null) {
+  if (x === null) {
     return "nil";
+  } else if (x === undefined) {
+    return "&unit";
   } else if (x instanceof CalcitSymbol) {
     return x.value;
   } else if (x instanceof CalcitList || x instanceof CalcitSliceList) {

package/ts-src/custom-formatter.mts

@@ -21,9 +21,12 @@ declare global {
 }
 
 let embedObject = (x: CalcitValue) => {
-  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}`);
   }
@@ -77,16 +80,22 @@ let td = (style: any, ...children: any[]) => {
 
 /** handle null value in nested data */
 let saveString = (v: CalcitValue) => {
+  if (v === null) {
+    return "nil";
+  }
+  if (v === undefined) {
+    return "&unit";
+  }
   if (typeof v === "string") {
     if (v.match(/[\s\"\n\t\,]/)) {
       return `"|${v}"`;
     } else {
       return `|${v}`;
     }
-  } else if (v != null && v.toString) {
+  } else if (v.toString) {
     return v.toString();
   } else {
-    return "nil";
+    return String(v);
   }
 };
 

package/ts-src/js-cirru.mts

@@ -6,7 +6,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";
@@ -87,9 +87,12 @@ export let format_cirru_one_liner = (data: CalcitCirruQuote | CalcitList): strin
 
 /** better use string version of Cirru EDN in future */
 export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
-  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}`;
   }
@@ -352,9 +355,7 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
           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: Array<CalcitTag> = [];
       let values: Array<CalcitValue> = [];
 

package/ts-src/js-impl.mts

@@ -1,6 +1,6 @@
 import { Hash } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
-import { CalcitTag, castTag, findInFields, toString } from "./calcit-data.mjs";
+import { CalcitTag, canonicalizeTagPairs, castTag, findInFields, toString } from "./calcit-data.mjs";
 import type { CalcitTrait } from "./js-trait.mjs";
 
 const CALCIT_IMPL_BRAND = Symbol.for("@calcit/procs/CalcitImpl");
@@ -44,10 +44,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;
   }
 

package/ts-src/js-primes.mts

@@ -32,6 +32,7 @@ export type CalcitValue =
   | CalcitStructDef
   | CalcitEnumDef
   | CalcitCirruQuote
+  | undefined
   | null;
 
 export let isLiteral = (x: CalcitValue): boolean => {
@@ -46,6 +47,7 @@ export let isLiteral = (x: CalcitValue): boolean => {
 
 enum PseudoTypeIndex {
   nil,
+  unit,
   bool,
   number,
   symbol,
@@ -67,7 +69,8 @@ enum PseudoTypeIndex {
 
 let typeAsInt = (x: CalcitValue): number => {
   // based on order used in Ord trait
-  if (x == null) return PseudoTypeIndex.nil;
+  if (x === null) return PseudoTypeIndex.nil;
+  if (x === undefined) return PseudoTypeIndex.unit;
   let t = typeof x;
   if (t === "boolean") return PseudoTypeIndex.bool;
   if (t === "number") return PseudoTypeIndex.number;
@@ -107,6 +110,7 @@ export let _$n_compare = (a: CalcitValue, b: CalcitValue): number => {
   if (ta === tb) {
     switch (ta) {
       case PseudoTypeIndex.nil:
+      case PseudoTypeIndex.unit:
         return 0;
       case PseudoTypeIndex.bool:
         return rawCompare(a, b);

package/ts-src/js-struct-def.mts

@@ -1,4 +1,4 @@
-import { CalcitTag, toString } from "./calcit-data.mjs";
+import { CalcitTag, canonicalizeTagPairs, toString } from "./calcit-data.mjs";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 
@@ -10,12 +10,10 @@ export class CalcitStructDef {
   cachedHash: number;
 
   constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls: CalcitImpl[] = []) {
-    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;
   }