@calcit/procs 0.13.0 → 0.13.2

package/lib/calcit.procs.mjs

@@ -5,21 +5,21 @@ 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 { CalcitRef, atom } from "./js-ref.mjs";
-import { CalcitRecord } from "./js-record.mjs";
+import { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitStructDef } from "./js-struct-def.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
 export * from "./calcit-data.mjs";
-export * from "./js-record.mjs";
+export * from "./js-struct-value.mjs";
 export * from "./js-impl.mjs";
-export * from "./js-struct.mjs";
-export * from "./js-enum.mjs";
+export * from "./js-struct-def.mjs";
+export * from "./js-enum-def.mjs";
 export * from "./js-map.mjs";
 export * from "./js-list.mjs";
 export * from "./js-set.mjs";
 export * from "./js-primes.mjs";
-export * from "./js-tuple.mjs";
+export * from "./js-enum-value.mjs";
 export * from "./js-trait.mjs";
 export * from "./custom-formatter.mjs";
 export * from "./js-cirru.mjs";
@@ -30,7 +30,7 @@ export { _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList, foldl } from "./js-list.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
-import { CalcitTuple } from "./js-tuple.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";
 let inNodeJs = typeof process !== "undefined" && process?.release?.name === "node";
@@ -56,8 +56,8 @@ export let type_of = (x) => {
     if (x instanceof CalcitRef) {
         return newTag("ref");
     }
-    if (x instanceof CalcitTuple) {
-        return newTag("tuple");
+    if (x instanceof CalcitEnumValue) {
+        return newTag("enum");
     }
     if (x instanceof CalcitSymbol) {
         return newTag("symbol");
@@ -65,17 +65,17 @@ export let type_of = (x) => {
     if (x instanceof CalcitSet) {
         return newTag("set");
     }
-    if (x instanceof CalcitRecord) {
-        return newTag("record");
+    if (x instanceof CalcitStructValue) {
+        return newTag("struct");
     }
     if (x instanceof CalcitImpl) {
         return newTag("impl");
     }
-    if (x instanceof CalcitStruct) {
-        return newTag("struct");
+    if (x instanceof CalcitStructDef) {
+        return newTag("struct-def");
     }
-    if (x instanceof CalcitEnum) {
-        return newTag("enum");
+    if (x instanceof CalcitEnumDef) {
+        return newTag("enum-def");
     }
     if (x instanceof CalcitTrait) {
         return newTag("trait");
@@ -185,7 +185,7 @@ export let _$n_assert_traits = function (value, traitDef) {
         throw new Error(`&assert-traits cannot resolve impls for: ${toString(value, true)}`);
     }
     const impls = pair[0];
-    const reverse = value instanceof CalcitRecord || value instanceof CalcitTuple || value instanceof CalcitStruct || value instanceof CalcitEnum;
+    const reverse = value instanceof CalcitStructValue || value instanceof CalcitEnumValue || value instanceof CalcitStructDef || value instanceof CalcitEnumDef;
     const ordered = reverse ? [...impls].reverse() : impls;
     const selected = ordered.find((impl) => impl != null && impl.origin === traitDef);
     if (selected == null) {
@@ -222,7 +222,7 @@ export let defstruct = (name, ...entries) => {
     }
     const fieldTags = fields.map((entry) => entry.tag);
     const fieldTypes = fields.map((entry) => entry.type);
-    return new CalcitStruct(structName, fieldTags, fieldTypes, null);
+    return new CalcitStructDef(structName, fieldTags, fieldTypes, null);
 };
 export let defenum = (name, ...variants) => {
     const enumName = castTag(name);
@@ -245,8 +245,8 @@ export let defenum = (name, ...variants) => {
     }
     const tags = entries.map((entry) => entry.tag);
     const values = entries.map((entry) => entry.payload);
-    const prototype = new CalcitRecord(enumName, tags, values, null);
-    return new CalcitEnum(prototype);
+    const prototype = new CalcitStructValue(enumName, tags, values, null);
+    return new CalcitEnumDef(prototype);
 };
 export let _$n_impl_$o__$o_new = (name, ...pairs) => {
     if (name === undefined)
@@ -257,13 +257,13 @@ export let _$n_impl_$o__$o_new = (name, ...pairs) => {
     let sourcePairs = pairs;
     if (pairs.length === 1 && pairs[0] instanceof CalcitImpl) {
         const sourceImpl = pairs[0];
-        sourcePairs = sourceImpl.fields.map((field, idx) => new CalcitTuple(newTag(field.value), [sourceImpl.values[idx]], null));
+        sourcePairs = sourceImpl.fields.map((field, idx) => new CalcitEnumValue(newTag(field.value), [sourceImpl.values[idx]], null));
     }
     for (let idx = 0; idx < sourcePairs.length; idx++) {
         const pairValue = sourcePairs[idx];
         let fieldTag;
         let value;
-        if (pairValue instanceof CalcitTuple) {
+        if (pairValue instanceof CalcitEnumValue) {
             if (pairValue.extra.length !== 1) {
                 throw new Error(`&impl::new expects (field value) pairs, got: ${toString(pairValue, true)}`);
             }
@@ -307,10 +307,10 @@ export let _$n_impl_$o__$o_new = (name, ...pairs) => {
     }
     return new CalcitImpl(implName, fields, values, origin);
 };
-export let _$n_struct_$o__$o_new = (name, ...entries) => {
+export let _$n_struct_def_$o_new = (name, ...entries) => {
     return defstruct(name, ...entries);
 };
-export let _$n_enum_$o__$o_new = (name, ...variants) => {
+export let _$n_enum_def_$o_new = (name, ...variants) => {
     return defenum(name, ...variants);
 };
 export let print = (...xs) => {
@@ -332,25 +332,25 @@ export function _$n_map_$o_count(x) {
         return x.len();
     throw new Error(`expected a map ${x}`);
 }
-export function _$n_record_$o_count(x) {
-    if (x instanceof CalcitRecord)
+export function _$n_struct_$o_count(x) {
+    if (x instanceof CalcitStructValue)
         return x.fields.length;
-    throw new Error(`expected a record ${x}`);
+    throw new Error(`expected a struct value ${x}`);
 }
-export function _$n_record_$o_field_tag(x, idx) {
-    if (!(x instanceof CalcitRecord))
-        throw new Error(`&record:field-tag expected a record, got ${x}`);
+export function _$n_struct_$o_field_tag(x, idx) {
+    if (!(x instanceof CalcitStructValue))
+        throw new Error(`&struct:field-tag expected a struct value, got ${x}`);
     const i = idx;
     if (i < 0 || i >= x.fields.length)
-        throw new Error(`&record:field-tag index ${i} out of bounds (${x.fields.length})`);
+        throw new Error(`&struct:field-tag index ${i} out of bounds (${x.fields.length})`);
     return x.fields[i];
 }
-export function _$n_record_$o_nth(x, idx) {
-    if (!(x instanceof CalcitRecord))
-        throw new Error(`&record:nth expected a record, got ${x}`);
+export function _$n_struct_$o_nth(x, idx) {
+    if (!(x instanceof CalcitStructValue))
+        throw new Error(`&struct:nth expected a struct value, got ${x}`);
     const i = idx;
     if (i < 0 || i >= x.values.length)
-        throw new Error(`&record:nth index ${i} out of range for record with ${x.values.length} fields`);
+        throw new Error(`&struct:nth index ${i} out of range for struct with ${x.values.length} fields`);
     return x.values[i];
 }
 export function _$n_set_$o_count(x) {
@@ -434,10 +434,10 @@ export let _$n_map_$o_contains_$q_ = (xs, x) => {
         return xs.contains(x);
     throw new Error("map `contains?` expected a map");
 };
-export let _$n_record_$o_contains_$q_ = (xs, x) => {
-    if (xs instanceof CalcitRecord)
+export let _$n_struct_$o_contains_$q_ = (xs, x) => {
+    if (xs instanceof CalcitStructValue)
         return xs.contains(x);
-    throw new Error("record `contains?` expected a record");
+    throw new Error("struct `contains?` expected a struct value");
 };
 export let _$n_str_$o_includes_$q_ = (xs, x) => {
     if (typeof xs === "string") {
@@ -497,19 +497,19 @@ export let _$n_list_$o_nth = function (xs, k) {
         return xs.get(k);
     throw new Error("Does not support `nth` on this type");
 };
-export let _$n_tuple_$o_nth = function (xs, k) {
+export let _$n_enum_$o_nth = function (xs, k) {
     if (arguments.length !== 2)
         throw new Error("nth takes 2 arguments");
     if (typeof k !== "number")
         throw new Error("Expected number index for a list");
-    if (xs instanceof CalcitTuple)
+    if (xs instanceof CalcitEnumValue)
         return xs.get(k);
     throw new Error("Does not support `nth` on this type");
 };
-export let _$n_tuple_$o_count = function (xs) {
+export let _$n_enum_$o_count = function (xs) {
     if (arguments.length !== 1)
-        throw new Error("&tuple:count takes 1 arguments");
-    if (xs instanceof CalcitTuple)
+        throw new Error("&enum:count takes 1 arguments");
+    if (xs instanceof CalcitEnumValue)
         return xs.count();
     throw new Error("Does not support `count` on this type");
 };
@@ -519,63 +519,60 @@ const coerce_impl = (value, procName) => {
     }
     throw new Error(`${procName} expects trait impls as impls`);
 };
-export let _$n_tuple_$o_impls = function (x) {
+export let _$n_enum_$o_impls = function (x) {
     if (arguments.length !== 1)
-        throw new Error("&tuple:impls takes 1 argument");
+        throw new Error("&enum:impls takes 1 argument");
     return new CalcitSliceList(x.impls);
 };
-export let _$n_tuple_$o_params = function (x) {
+export let _$n_enum_$o_params = function (x) {
     if (arguments.length !== 1)
-        throw new Error("&tuple:params takes 1 argument");
+        throw new Error("&enum:params takes 1 argument");
     return new CalcitSliceList(x.extra);
 };
-export let _$n_tuple_$o_with_impls = function (x, y) {
+export let _$n_enum_$o_with_impls = function (x, y) {
     if (arguments.length !== 2)
-        throw new Error("&tuple:with-impls takes 2 arguments");
-    if (!(x instanceof CalcitTuple))
-        throw new Error("&tuple:with-impls expects a tuple");
-    const impl = coerce_impl(y, "&tuple:with-impls");
+        throw new Error("&enum:with-impls takes 2 arguments");
+    if (!(x instanceof CalcitEnumValue))
+        throw new Error("&enum:with-impls expects an enum value");
+    const impl = coerce_impl(y, "&enum:with-impls");
     let proto = x.enumPrototype;
     if (proto == null) {
-        proto = new CalcitEnum(new CalcitRecord(newTag("anonymous-tuple"), [], [], new CalcitStruct(newTag("anonymous-tuple"), [], [])));
+        proto = new CalcitEnumDef(new CalcitStructValue(newTag("_"), [], [], new CalcitStructDef(newTag("_"), [], [])));
     }
-    return new CalcitTuple(x.tag, x.extra, proto.withImpls(impl));
+    return new CalcitEnumValue(x.tag, x.extra, proto.withImpls(impl));
 };
-export let _$n_tuple_$o_impl_traits = function (x, ...traits) {
+export let _$n_enum_$o_impl_traits = function (x, ...traits) {
     if (traits.length < 1)
-        throw new Error("&tuple:impl-traits takes 2+ arguments");
-    if (!(x instanceof CalcitTuple))
-        throw new Error("&tuple:impl-traits expects a tuple");
-    const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
+        throw new Error("&enum:impl-traits takes 2+ arguments");
+    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"));
     let proto = x.enumPrototype;
     if (proto == null) {
         const tagName = x.tag instanceof CalcitTag ? x.tag : newTag("tag");
         const anyTypes = new CalcitSliceList(new Array(x.extra.length).fill(newTag("any")));
-        proto = new CalcitEnum(new CalcitRecord(newTag("anonymous-tuple"), [tagName], [anyTypes], new CalcitStruct(newTag("anonymous-tuple"), [tagName], [anyTypes])));
+        proto = new CalcitEnumDef(new CalcitStructValue(newTag("_"), [tagName], [anyTypes], new CalcitStructDef(newTag("_"), [tagName], [anyTypes])));
     }
-    return new CalcitTuple(x.tag, x.extra, proto.withImpls(impls));
+    return new CalcitEnumValue(x.tag, x.extra, proto.withImpls(impls));
 };
-export let _$n_tuple_$o_enum = function (x) {
+export let _$n_enum_$o_definition = function (x) {
     if (arguments.length !== 1)
-        throw new Error("&tuple:enum takes 1 argument");
-    if (!(x instanceof CalcitTuple))
-        throw new Error("&tuple:enum expects a tuple");
+        throw new Error("&enum:definition takes 1 argument");
+    if (!(x instanceof CalcitEnumValue))
+        throw new Error("&enum:definition expects an enum value");
     if (x.enumPrototype == null) {
         return null;
     }
-    if (x.enumPrototype instanceof CalcitEnum) {
-        return x.enumPrototype;
-    }
-    return new CalcitEnum(x.enumPrototype);
+    return x.enumPrototype;
 };
 const unwrap_enum_prototype = (enumPrototype, procName) => {
-    if (enumPrototype instanceof CalcitEnum) {
+    if (enumPrototype instanceof CalcitEnumDef) {
         return enumPrototype.prototype;
     }
-    if (enumPrototype instanceof CalcitRecord) {
-        return enumPrototype;
+    if (enumPrototype instanceof CalcitStructValue) {
+        throw new Error(`${procName} no longer accepts a struct prototype; pass an EnumDef produced by defenum`);
     }
-    throw new Error(`${procName} expects enum prototype as first argument`);
+    throw new Error(`${procName} expects an EnumDef as first argument`);
 };
 const assert_enum_tag_args = (procName, enumPrototype, variantTag) => {
     const proto = unwrap_enum_prototype(enumPrototype, procName);
@@ -584,17 +581,17 @@ const assert_enum_tag_args = (procName, enumPrototype, variantTag) => {
     }
     return proto;
 };
-export let _$n_tuple_$o_enum_has_variant_$q_ = function (enumPrototype, variantTag) {
+export let _$n_enum_def_$o_has_variant_$q_ = function (enumPrototype, variantTag) {
     if (arguments.length !== 2)
-        throw new Error("&tuple:enum-has-variant? takes 2 arguments");
-    const proto = assert_enum_tag_args("&tuple:enum-has-variant?", enumPrototype, variantTag);
+        throw new Error("&enum-def:has-variant? takes 2 arguments");
+    const proto = assert_enum_tag_args("&enum-def:has-variant?", enumPrototype, variantTag);
     return proto.contains(variantTag);
 };
-export let _$n_tuple_$o_enum_has_variant = _$n_tuple_$o_enum_has_variant_$q_;
-export let _$n_tuple_$o_enum_variant_arity = function (enumPrototype, variantTag) {
+export let _$n_enum_def_$o_has_variant = _$n_enum_def_$o_has_variant_$q_;
+export let _$n_enum_def_$o_variant_arity = function (enumPrototype, variantTag) {
     if (arguments.length !== 2)
-        throw new Error("&tuple:enum-variant-arity takes 2 arguments");
-    const proto = assert_enum_tag_args("&tuple:enum-variant-arity", enumPrototype, variantTag);
+        throw new Error("&enum-def:variant-arity takes 2 arguments");
+    const proto = assert_enum_tag_args("&enum-def:variant-arity", enumPrototype, variantTag);
     const variant = proto.getOrNil(variantTag);
     if (variant === undefined) {
         throw new Error(`Variant ${variantTag.value} not found in enum ${proto.name.value}`);
@@ -604,36 +601,36 @@ export let _$n_tuple_$o_enum_variant_arity = function (enumPrototype, variantTag
     }
     throw new Error("Expected variant to be a list");
 };
-export let _$n_tuple_$o_validate_enum = function (tuple, tag) {
+export let _$n_enum_$o_validate = function (enumValue, tag) {
     if (arguments.length !== 2)
-        throw new Error("&tuple:validate-enum takes 2 arguments");
-    if (!(tuple instanceof CalcitTuple))
-        throw new Error("&tuple:validate-enum expects a tuple as first argument");
-    if (tuple.enumPrototype == null) {
+        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;
     }
-    const proto = assert_enum_tag_args("&tuple:validate-enum", tuple.enumPrototype, tag);
+    const proto = assert_enum_tag_args("&enum:validate", enumValue.enumPrototype, tag);
     const tagValue = tag;
     const variant = proto.getOrNil(tagValue);
     if (variant === undefined) {
-        throw new Error(`enum does not have variant ${tagValue.value} for ${tuple}`);
+        throw new Error(`enum does not have variant ${tagValue.value} for ${enumValue}`);
     }
     if (variant instanceof CalcitSliceList) {
         const expected = variant.len();
-        const actual = tuple.extra.length;
+        const actual = enumValue.extra.length;
         if (expected !== actual) {
-            throw new Error(`enum variant expects ${expected} payload(s), got ${actual} for ${tuple}`);
+            throw new Error(`enum variant expects ${expected} payload(s), got ${actual} for ${enumValue}`);
         }
         return null;
     }
     throw new Error("Expected variant to be a list");
 };
-export let _$n_record_$o_get = function (xs, k) {
+export let _$n_struct_$o_get = function (xs, k) {
     if (arguments.length !== 2) {
-        throw new Error("record &get takes 2 arguments");
+        throw new Error("&struct:get takes 2 arguments");
     }
-    if (xs instanceof CalcitRecord)
-        return xs.get(k);
+    if (xs instanceof CalcitStructValue)
+        return xs.getRequired(k);
     throw new Error("Does not support `&get` on this type");
 };
 export let _$n_list_$o_assoc = function (xs, k, v) {
@@ -647,16 +644,16 @@ export let _$n_list_$o_assoc = function (xs, k, v) {
     }
     throw new Error("list `assoc` expected a list");
 };
-export let _$n_tuple_$o_assoc = function (xs, k, v) {
+export let _$n_enum_$o_assoc = function (xs, k, v) {
     if (arguments.length !== 3)
         throw new Error("assoc takes 3 arguments");
-    if (xs instanceof CalcitTuple) {
+    if (xs instanceof CalcitEnumValue) {
         if (typeof k !== "number") {
             throw new Error("Expected number index for lists");
         }
         return xs.assoc(k, v);
     }
-    throw new Error("tuple `assoc` expected a tuple");
+    throw new Error("enum `assoc` expected an enum value");
 };
 export let _$n_map_$o_assoc = function (xs, ...args) {
     if (arguments.length < 3)
@@ -667,50 +664,46 @@ export let _$n_map_$o_assoc = function (xs, ...args) {
         return xs.assoc(...args);
     throw new Error("map `assoc` expected a map");
 };
-export let _$n_record_$o_assoc = function (xs, k, v) {
+export let _$n_struct_$o_assoc = function (xs, k, v) {
     if (arguments.length !== 3)
         throw new Error("assoc takes 3 arguments");
-    if (xs instanceof CalcitRecord)
+    if (xs instanceof CalcitStructValue)
         return xs.assoc(k, v);
-    throw new Error("record `assoc` expected a record");
+    throw new Error("struct `assoc` expected a struct value");
 };
-export let _$n_record_$o_impls = function (xs) {
+export let _$n_struct_$o_impls = function (xs) {
     if (arguments.length !== 1)
-        throw new Error("&record:impls takes 1 argument");
-    if (xs instanceof CalcitRecord)
+        throw new Error("&struct:impls takes 1 argument");
+    if (xs instanceof CalcitStructValue)
         return new CalcitSliceList(xs.structRef.impls);
-    throw new Error("&record:impls expected a record");
-};
-export let _$n_record_$o_impl_traits = function (xs, ...traits) {
-    if (traits.length < 1)
-        throw new Error("&record:impl-traits takes 2+ arguments");
-    if (!(xs instanceof CalcitRecord))
-        throw new Error("&record:impl-traits expected a record");
-    const impls = traits.map((trait) => coerce_impl(trait, "&record:impl-traits"));
-    const nextStruct = new CalcitStruct(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(impls));
-    return new CalcitRecord(xs.name, xs.fields, xs.values, nextStruct);
+    throw new Error("&struct:impls expected a struct value");
 };
 export let _$n_struct_$o_impl_traits = function (xs, ...traits) {
     if (traits.length < 1)
         throw new Error("&struct:impl-traits takes 2+ arguments");
-    if (!(xs instanceof CalcitStruct))
-        throw new Error("&struct:impl-traits expected a struct");
-    const addedImpls = traits.map((trait) => coerce_impl(trait, "&struct:impl-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));
+    return new CalcitStructValue(xs.name, xs.fields, xs.values, nextStruct);
+};
+export let _$n_struct_def_$o_impl_traits = function (xs, ...traits) {
+    if (traits.length < 1)
+        throw new Error("&struct-def:impl-traits takes 2+ arguments");
+    if (!(xs instanceof CalcitStructDef))
+        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 CalcitStruct(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls));
+    return new CalcitStructDef(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls));
 };
-export let _$n_enum_$o_impl_traits = function (xs, ...traits) {
+export let _$n_enum_def_$o_impl_traits = function (xs, ...traits) {
     if (traits.length < 1)
-        throw new Error("&enum:impl-traits takes 2+ arguments");
-    const addedImpls = traits.map((trait) => coerce_impl(trait, "&enum:impl-traits"));
-    if (xs instanceof CalcitEnum) {
+        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) {
         return xs.withImpls(addedImpls);
     }
-    if (xs instanceof CalcitRecord) {
-        const nextStruct = new CalcitStruct(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(addedImpls));
-        return new CalcitRecord(xs.name, xs.fields, xs.values, nextStruct);
-    }
-    throw new Error("&enum:impl-traits expected an enum or enum record");
+    throw new Error("&enum-def:impl-traits expected an enum definition");
 };
 export let _$n_impl_$o_origin = function (impl) {
     if (arguments.length !== 1)
@@ -1089,7 +1082,7 @@ export let _$n_merge = (a, b) => {
             throw new Error("Expected an argument of map");
         }
     }
-    if (a instanceof CalcitRecord) {
+    if (a instanceof CalcitStructValue) {
         if (b instanceof CalcitMap || b instanceof CalcitSliceMap) {
             let values = [];
             for (let idx = 0; idx < a.values.length; idx++) {
@@ -1114,10 +1107,10 @@ export let _$n_merge = (a, b) => {
                     throw new Error(`Cannot find field ${field} among (${a.fields.join(", ")})`);
                 }
             }
-            return new CalcitRecord(a.name, a.fields, values);
+            return new CalcitStructValue(a.name, a.fields, values);
         }
     }
-    throw new Error("Expected map or record");
+    throw new Error("Expected map or struct value");
 };
 export let _$n_merge_non_nil = (a, b) => {
     if (a == null) {
@@ -1143,7 +1136,7 @@ export let to_pairs = (xs) => {
         }
         return new CalcitSet(result);
     }
-    else if (xs instanceof CalcitRecord) {
+    else if (xs instanceof CalcitStructValue) {
         let arr_result = [];
         for (let idx = 0; idx < xs.fields.length; idx++) {
             arr_result.push(new CalcitSliceList([xs.fields[idx], xs.values[idx]]));
@@ -1493,11 +1486,17 @@ export let fn_$q_ = (x) => {
 export let ref_$q_ = (x) => {
     return x instanceof CalcitRef;
 };
-export let record_$q_ = (x) => {
-    return x instanceof CalcitRecord;
+export let struct_$q_ = (x) => {
+    if (x instanceof CalcitStructDef) {
+        throw new Error("`struct?` now checks struct values; use `struct-def?` for a value produced by `defstruct`");
+    }
+    return x instanceof CalcitStructValue;
 };
-export let tuple_$q_ = (x) => {
-    return x instanceof CalcitTuple;
+export let enum_$q_ = (x) => {
+    if (x instanceof CalcitEnumDef) {
+        throw new Error("`enum?` now checks enum values; use `enum-def?` for a value produced by `defenum`");
+    }
+    return x instanceof CalcitEnumValue;
 };
 export let buffer_$q_ = (x) => {
     console.warn("TODO, detecting buffer");
@@ -1559,10 +1558,10 @@ const typed_edn_kind = (value) => {
         return "map";
     if (value instanceof CalcitSet || value instanceof TypedEdnSetView)
         return "set";
-    if (value instanceof CalcitRecord)
-        return "record";
-    if (value instanceof CalcitTuple)
-        return value.enumPrototype == null ? "tuple" : "enum";
+    if (value instanceof CalcitStructValue)
+        return "struct";
+    if (value instanceof CalcitEnumValue)
+        return "enum";
     if (value instanceof CalcitRef)
         return "atom";
     if (value instanceof CalcitCirruQuote)
@@ -1575,7 +1574,7 @@ const typed_edn_error = (path, message) => {
     throw new Error(`parse-cirru-edn-as failed at ${path}: ${message}`);
 };
 const enum_prototype_name = (value) => {
-    return value instanceof CalcitEnum ? value.name() : value.name.value;
+    return value instanceof CalcitEnumDef ? value.name() : value.name.value;
 };
 const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
     if (depth > 1024)
@@ -1664,18 +1663,18 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
                 return typed_edn_error(path, `expected atom, got ${typed_edn_kind(input)}`);
             return atom(decode_typed_edn_node(graph, node.inner, input.value, `${path}.value`, depth + 1));
         case "struct": {
-            if (!(input instanceof CalcitRecord)) {
-                return typed_edn_error(path, `expected record :${node.nominal.name.value}, got ${typed_edn_kind(input)}`);
+            if (!(input instanceof CalcitStructValue)) {
+                return typed_edn_error(path, `expected struct :${node.nominal.name.value}, got ${typed_edn_kind(input)}`);
             }
             if (input.name.value !== node.nominal.name.value) {
-                return typed_edn_error(path, `expected record :${node.nominal.name.value}, got record :${input.name.value}`);
+                return typed_edn_error(path, `expected struct :${node.nominal.name.value}, got struct :${input.name.value}`);
             }
             const expectedNames = node.fields.map(([name]) => name);
             const actualNames = input.fields.map((field) => field.value);
             const missing = expectedNames.filter((name) => !actualNames.includes(name)).sort();
             const unknown = actualNames.filter((name) => !expectedNames.includes(name)).sort();
             if (missing.length > 0 || unknown.length > 0 || expectedNames.length !== actualNames.length) {
-                return typed_edn_error(path, `record :${node.nominal.name.value} fields mismatch; missing [${missing.join(", ")}], unknown [${unknown.join(", ")}]`);
+                return typed_edn_error(path, `struct :${node.nominal.name.value} fields mismatch; missing [${missing.join(", ")}], unknown [${unknown.join(", ")}]`);
             }
             const decodedFields = new Map();
             node.fields.forEach(([name, fieldNode]) => {
@@ -1685,18 +1684,18 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
             // Native declarations use lexical field order while the JS runtime keeps
             // its interned-tag order. Re-align values to the nominal JS declaration.
             if (decodedFields.size !== node.nominal.fields.length) {
-                return typed_edn_error(path, `record :${node.nominal.name.value} decoder fields do not match its nominal declaration`);
+                return typed_edn_error(path, `struct :${node.nominal.name.value} decoder fields do not match its nominal declaration`);
             }
             const values = node.nominal.fields.map((field) => {
                 if (!decodedFields.has(field.value)) {
-                    return typed_edn_error(path, `record :${node.nominal.name.value} is missing declared field :${field.value}`);
+                    return typed_edn_error(path, `struct :${node.nominal.name.value} is missing declared field :${field.value}`);
                 }
                 return decodedFields.get(field.value);
             });
-            return new CalcitRecord(node.nominal.name, node.nominal.fields, values, node.nominal);
+            return new CalcitStructValue(node.nominal.name, node.nominal.fields, values, node.nominal);
         }
         case "enum": {
-            if (!(input instanceof CalcitTuple) || input.enumPrototype == null) {
+            if (!(input instanceof CalcitEnumValue) || input.enumPrototype == null) {
                 return typed_edn_error(path, `expected enum :${node.nominal.name()}, got ${typed_edn_kind(input)}`);
             }
             const actualEnumName = enum_prototype_name(input.enumPrototype);
@@ -1715,7 +1714,7 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
                 return typed_edn_error(path, `enum :${node.nominal.name()} variant :${variant.tag} expects ${variant.payload.length} payload(s), got ${input.extra.length}`);
             }
             const values = variant.payload.map((payloadNode, idx) => decode_typed_edn_node(graph, payloadNode, input.extra[idx], `${path}.payload[${idx}]`, depth + 1));
-            return new CalcitTuple(newTag(variant.tag), values, node.nominal);
+            return new CalcitEnumValue(newTag(variant.tag), values, node.nominal);
         }
         default:
             return typed_edn_error(path, `invalid data shape node kind: ${node.kind}`);
@@ -1811,13 +1810,13 @@ const calcit_to_json = (value) => {
         }
         return result;
     }
-    if (value instanceof CalcitTuple) {
+    if (value instanceof CalcitEnumValue) {
         return [calcit_to_json(value.tag), ...value.extra.map(calcit_to_json)];
     }
     if (value instanceof CalcitCirruQuote) {
         return cirru_quote_to_json(value.value);
     }
-    if (value instanceof CalcitRecord) {
+    if (value instanceof CalcitStructValue) {
         const result = {};
         for (let idx = 0; idx < value.fields.length; idx++) {
             result[value.fields[idx].value] = calcit_to_json(value.values[idx]);
@@ -1932,7 +1931,7 @@ export let _$n_js_object = (...xs) => {
     return ret;
 };
 export let _$o__$o_ = (tagName, ...extra) => {
-    return new CalcitTuple(tagName, extra, null);
+    return new CalcitEnumValue(tagName, extra, null);
 };
 export let _PCT__$o__$o_ = (enumPrototype, tag, ...extra) => {
     const proto = assert_enum_tag_args("%::", enumPrototype, tag);
@@ -1951,8 +1950,7 @@ export let _PCT__$o__$o_ = (enumPrototype, tag, ...extra) => {
     else {
         throw new Error(`Expected variant definition to be a list, got ${variantDefinition}`);
     }
-    const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
-    return new CalcitTuple(tag, extra, tupleEnumPrototype);
+    return new CalcitEnumValue(tag, extra, enumPrototype);
 };
 export let _PCT__PCT__$o__$o_ = (impl, enumPrototype, tag, ...extra) => {
     // Runtime validation: check if tag exists in enum and arity matches
@@ -1972,9 +1970,8 @@ export let _PCT__PCT__$o__$o_ = (impl, enumPrototype, tag, ...extra) => {
     else {
         throw new Error(`Expected variant definition to be a list, got ${variantDefinition}`);
     }
-    const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
     const implValue = coerce_impl(impl, "%:: with impl");
-    return new CalcitTuple(tag, extra, tupleEnumPrototype.withImpls(implValue));
+    return new CalcitEnumValue(tag, extra, enumPrototype.withImpls(implValue));
 };
 let calcit_builtin_impls = {
     number: null,
@@ -1983,8 +1980,8 @@ let calcit_builtin_impls = {
     list: null,
     map: null,
     fn: null,
-    tuple: null,
-    record: null,
+    enum: null,
+    struct: null,
     scalar: null,
 };
 // need to register code from outside
@@ -2024,10 +2021,10 @@ function lookup_impls(obj) {
         tag = "&core-map-methods";
         impls = normalize_builtin_impls(calcit_builtin_impls.map);
     }
-    else if (obj instanceof CalcitRecord) {
+    else if (obj instanceof CalcitStructValue) {
         tag = obj.name.toString();
         let instanceImpls = obj.structRef.impls;
-        let builtinRecordImpls = normalize_builtin_impls(calcit_builtin_impls.record);
+        let builtinRecordImpls = normalize_builtin_impls(calcit_builtin_impls.struct);
         if (builtinRecordImpls && instanceImpls && instanceImpls.length > 0) {
             impls = [...builtinRecordImpls, ...instanceImpls];
         }
@@ -2038,10 +2035,10 @@ function lookup_impls(obj) {
             impls = instanceImpls;
         }
     }
-    else if (obj instanceof CalcitTuple) {
+    else if (obj instanceof CalcitEnumValue) {
         tag = obj.tag.toString();
         let instanceImpls = obj.impls;
-        let builtinTupleImpls = normalize_builtin_impls(calcit_builtin_impls.tuple);
+        let builtinTupleImpls = normalize_builtin_impls(calcit_builtin_impls.enum);
         if (builtinTupleImpls && instanceImpls && instanceImpls.length > 0) {
             impls = [...builtinTupleImpls, ...instanceImpls];
         }
@@ -2056,17 +2053,17 @@ function lookup_impls(obj) {
         tag = "&core-set-methods";
         impls = normalize_builtin_impls(calcit_builtin_impls.set);
     }
-    else if (obj instanceof CalcitStruct) {
+    else if (obj instanceof CalcitStructDef) {
         // Bare type definitions (not yet instantiated) carry their own attached
         // impls, so introspection tools like `&methods-of` can answer "what
         // methods will instances of this type have" without a concrete instance.
         tag = obj.name.toString();
-        const builtinRecordImpls = normalize_builtin_impls(calcit_builtin_impls.record) ?? [];
+        const builtinRecordImpls = normalize_builtin_impls(calcit_builtin_impls.struct) ?? [];
         impls = [...builtinRecordImpls, ...(obj.impls ?? [])];
     }
-    else if (obj instanceof CalcitEnum) {
+    else if (obj instanceof CalcitEnumDef) {
         tag = obj.name();
-        const builtinTupleImpls = normalize_builtin_impls(calcit_builtin_impls.tuple) ?? [];
+        const builtinTupleImpls = normalize_builtin_impls(calcit_builtin_impls.enum) ?? [];
         impls = [...builtinTupleImpls, ...(obj.impls ?? [])];
     }
     else if (typeof obj === "number") {
@@ -2105,7 +2102,7 @@ export function invoke_method(p, obj, ...args) {
     let tag = pair[1];
     // builtin impl lists are ordered by priority in calcit-core.
     // user-defined values use impl-traits append, so later impls override earlier ones.
-    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
+    let 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) {
         let klass = impls[idx];
@@ -2134,7 +2131,7 @@ export function _$n_methods_of(obj) {
         throw new Error(`&methods-of cannot resolve impls for: ${toString(obj, true)}`);
     }
     let impls = pair[0];
-    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
+    let reverse = obj instanceof CalcitStructValue || obj instanceof CalcitEnumValue || obj instanceof CalcitStructDef || obj instanceof CalcitEnumDef;
     let seen = new Set();
     let ys = [];
     let idx = reverse ? impls.length - 1 : 0;
@@ -2176,7 +2173,7 @@ export function _$n_inspect_methods(obj, note) {
         throw new Error(`&inspect-methods cannot resolve impls for: ${toString(obj, true)}`);
     }
     let impls = pair[0];
-    let reverse = obj instanceof CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
+    let reverse = obj instanceof CalcitStructValue || obj instanceof CalcitEnumValue || obj instanceof CalcitStructDef || obj instanceof CalcitEnumDef;
     console.log("\n&inspect-methods");
     console.log(`Note: ${toString(note, true)}`);
     console.log(`Value type: ${type_of(obj).toString()}`);
@@ -2225,7 +2222,7 @@ 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 CalcitRecord || obj instanceof CalcitTuple || obj instanceof CalcitStruct || obj instanceof CalcitEnum;
+    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];