@calcit/procs 0.13.1 → 0.13.2

package/editing-history/202608061714-struct-enum-data-model-v2.md

@@ -0,0 +1,39 @@
+# Struct / Enum data model v2
+
+## Scope
+
+- Split runtime definitions from values: `StructDef` / `EnumDef` versus `Struct` / `Enum`.
+- Replaced outward `record` / `tuple` names with `struct` / `enum`; historical snapshot input remains readable, but new writes and old API calls receive migration diagnostics.
+- Added canonical anonymous forms `%{} _ ...` and `%:: _ ...`.
+- Render named data definitions with symbols, for example `(%{} 'TodoState ...)`, in Rust display and the TypeScript custom formatter.
+
+## Field access contract
+
+- A struct has a fixed declared field set. Known-field `get` and postfix access return the field's declared type directly rather than `Option<T>`.
+- Missing struct fields produce static diagnostics when type information is available and ordinary runtime errors otherwise; they never turn into silent `nil`/`Option` absence.
+- Map, list, string, and other genuinely fallible collection lookups retain `Option` behavior.
+
+## Migration surface
+
+- Native APIs moved from `&record:*` / `&tuple:*` to `&struct:*` / `&enum:*`; definition-only operations use `&struct-def:*` / `&enum-def:*`.
+- Public reflection is `struct-definition` / `enum-definition`; predicates distinguish values (`struct?`, `enum?`) from definitions (`struct-def?`, `enum-def?`).
+- Removed calls emit `W_REMOVED_DATA_API` with concrete replacements. Compatibility wrapper bodies also fail explicitly if checking is bypassed.
+- Documentation now presents structs, enums, anonymous structs, and anonymous enums as the public model and keeps old spellings only in the migration table.
+
+## Recursive types and regressions
+
+- Recursive nominal references stay finite while being resolved.
+- `Optional<Node>` accepts a `nil` leaf and nested non-`nil` nodes.
+- Required invalid recursion and unsupported recursive data-shape forms return normal diagnostics instead of overflowing the stack.
+
+## Cross-backend work
+
+- Rust, JS, IR, and WASM emitters and runtime tags use the new semantic categories.
+- TypeScript runtime files are separated into struct/enum definition and value modules.
+- Custom formatter headers embed named and anonymous definition markers as `CalcitSymbol`, including `_`.
+
+## Real-project validation
+
+- Respo was migrated from legacy data APIs and predicates using AST leaf replacements.
+- `Element` stays a struct through `purify-element`, allowing direct typed field access and removing obsolete `Option` unwraps.
+- Respo check-only and its full JS test suite pass when loaded against this repository's newly compiled `@calcit/procs` runtime.

package/editing-history/202608061731-release-0.13.2.md

@@ -0,0 +1,18 @@
+# Release 0.13.2
+
+## Scope
+
+- Release the struct / enum data model cleanup merged by PR #301.
+- Publish direct required Struct field access and migration diagnostics for removed record / tuple APIs.
+- Publish symbol-based nominal formatting and matching TypeScript runtime modules.
+
+## Version synchronization
+
+- `Cargo.toml`: `0.13.2`
+- `package.json`: `0.13.2`
+- `Cargo.lock`: refreshed with `cargo update --workspace`
+
+## Release gates
+
+- The feature PR passed Test and all CodeQL jobs before merge.
+- The release commit must pass the same GitHub Actions checks before tag `0.13.2` is created.

package/history/202608061433-required-record-field-access.md

@@ -0,0 +1,32 @@
+# Required record field access
+
+## Background
+
+Struct-backed values and loose records both have a fixed runtime field set.
+Direct field syntax therefore must not inherit the optional semantics of the
+generic collection `get` API: a declared field returns its value directly and
+an absent field is an ordinary diagnostic.
+
+## Changes
+
+- Specialize postfix and tag-headed record access to indexed or required
+  record lookup during preprocessing.
+- Make missing native record fields fail consistently in the Rust, JavaScript,
+  and WASM runtimes instead of producing nil or undefined.
+- Keep the public collection `get` API optional by guarding required record
+  lookup with `record:contains?`.
+- Add Rust and JavaScript regression coverage for direct field specialization
+  and missing-field diagnostics.
+- Update the internal `&record:get` schema and documentation to describe the
+  required lookup contract.
+
+## Verification
+
+- `cargo fmt`
+- `cargo clippy -- -D warnings`
+- `cargo test`
+- `yarn compile`
+- `yarn check-all`
+- `yarn check-agent-interface`
+- Respo `cr calcit.cirru --check-only`
+- Respo `cr calcit.cirru js`

package/lib/calcit-data.mjs

@@ -2,15 +2,15 @@ import { overwriteHashGenerator, valueHash, mergeValueHash } from "@calcit/terna
 import { overwriteComparator } from "@calcit/ternary-tree";
 import { overwriteMapComparator } from "./js-map.mjs";
 import { disableListStructureCheck } from "@calcit/ternary-tree";
-import { CalcitRecord, fieldsEqual } from "./js-record.mjs";
+import { CalcitStructValue, fieldsEqual } 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 { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitSet, overwriteSetComparator } from "./js-set.mjs";
-import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
 import { CalcitCirruQuote, cirru_deep_equal } from "./js-cirru.mjs";
 import { CalcitRef } from "./js-ref.mjs";
@@ -64,7 +64,7 @@ export let isNestedCalcitData = (x) => {
     if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
         return x.len() > 0;
     }
-    if (x instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
         return x.fields.length > 0;
     }
     if (x instanceof CalcitImpl) {
@@ -82,7 +82,7 @@ export let tipNestedCalcitData = (x) => {
     if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
         return "'{}...";
     }
-    if (x instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
         return "'%{}...";
     }
     if (x instanceof CalcitImpl) {
@@ -228,7 +228,7 @@ export let hashFunction = (x) => {
         x.cachedHash = h;
         return h;
     }
-    if (x instanceof CalcitTuple) {
+    if (x instanceof CalcitEnumValue) {
         let base = defaultHash_tuple;
         base = mergeValueHash(base, hashFunction(x.tag));
         for (let idx = 0; idx < x.extra.length; idx++) {
@@ -293,7 +293,7 @@ export let hashFunction = (x) => {
         x.cachedHash = base;
         return base;
     }
-    if (x instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
         let base = defaultHash_record;
         for (let idx = 0; idx < x.fields.length; idx++) {
             base = mergeValueHash(base, hashFunction(x.fields[idx]));
@@ -315,7 +315,7 @@ export let hashFunction = (x) => {
         x.cachedHash = base;
         return base;
     }
-    if (x instanceof CalcitStruct) {
+    if (x instanceof CalcitStructDef) {
         let base = defaultHash_struct;
         base = mergeValueHash(base, hashFunction(x.name));
         for (let idx = 0; idx < x.fields.length; idx++) {
@@ -328,7 +328,7 @@ export let hashFunction = (x) => {
         x.cachedHash = base;
         return base;
     }
-    if (x instanceof CalcitEnum) {
+    if (x instanceof CalcitEnumDef) {
         let base = defaultHash_enum;
         base = mergeValueHash(base, hashFunction(x.prototype));
         for (let impl of x.impls) {
@@ -412,16 +412,16 @@ export let toString = (x, escaped, disableJsDataWarning = false) => {
     if (x instanceof CalcitSet) {
         return x.toString(disableJsDataWarning);
     }
-    if (x instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
         return x.toString(disableJsDataWarning);
     }
     if (x instanceof CalcitImpl) {
         return x.toString(disableJsDataWarning);
     }
-    if (x instanceof CalcitStruct) {
+    if (x instanceof CalcitStructDef) {
         return x.toString(disableJsDataWarning);
     }
-    if (x instanceof CalcitEnum) {
+    if (x instanceof CalcitEnumDef) {
         return x.toString();
     }
     if (x instanceof CalcitTrait) {
@@ -430,7 +430,7 @@ export let toString = (x, escaped, disableJsDataWarning = false) => {
     if (x instanceof CalcitRef) {
         return x.toString();
     }
-    if (x instanceof CalcitTuple) {
+    if (x instanceof CalcitEnumValue) {
         return x.toString(disableJsDataWarning);
     }
     if (x instanceof CalcitCirruQuote) {
@@ -500,7 +500,7 @@ let to_js_data_inner = (x, addColon) => {
         }
         return Symbol(x.value);
     }
-    if (x instanceof CalcitTuple) {
+    if (x instanceof CalcitEnumValue) {
         var result = [to_js_data_inner(x.tag, false)];
         for (let i = 0; i < x.extra.length; i++) {
             let item = x.extra[i];
@@ -533,7 +533,7 @@ let to_js_data_inner = (x, addColon) => {
         });
         return result;
     }
-    if (x instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
         let result = {};
         for (let idx = 0; idx < x.fields.length; idx++) {
             result[x.fields[idx].value] = to_js_data_inner(x.values[idx], false);
@@ -654,8 +654,8 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
-    if (x instanceof CalcitTuple) {
-        if (y instanceof CalcitTuple) {
+    if (x instanceof CalcitEnumValue) {
+        if (y instanceof CalcitEnumValue) {
             return x.eq(y);
         }
         return false;
@@ -704,8 +704,8 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
-    if (x instanceof CalcitRecord) {
-        if (y instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
+        if (y instanceof CalcitStructValue) {
             if (x.name !== y.name) {
                 return false;
             }
@@ -750,14 +750,14 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
-    if (x instanceof CalcitStruct) {
-        if (y instanceof CalcitStruct) {
+    if (x instanceof CalcitStructDef) {
+        if (y instanceof CalcitStructDef) {
             return x.name === y.name && fieldsEqual(x.fields, y.fields);
         }
         return false;
     }
-    if (x instanceof CalcitEnum) {
-        if (y instanceof CalcitEnum) {
+    if (x instanceof CalcitEnumDef) {
+        if (y instanceof CalcitEnumDef) {
             return x.name === y.name;
         }
         return false;

package/lib/calcit.procs.d.mts

@@ -45,21 +45,21 @@ import { ICirruNode } from "@cirru/parser.ts";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitSymbol, CalcitTag, CalcitFn, CalcitRecur } from "./calcit-data.mjs";
 import { CalcitRef } 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";
@@ -70,23 +70,23 @@ export { _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList } 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 { CalcitCirruQuote } from "./js-cirru.mjs";
 export declare let type_of: (x: any) => CalcitTag;
 export declare let _$n_trait_$o__$o_new: (name: CalcitValue, methods: CalcitValue) => CalcitTrait;
 export declare let _$n_assert_traits: (value: CalcitValue, traitDef: CalcitValue) => CalcitValue;
-export declare let defstruct: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStruct;
-export declare let defenum: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnum;
+export declare let defstruct: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStructDef;
+export declare let defenum: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnumDef;
 export declare let _$n_impl_$o__$o_new: (name: CalcitValue, ...pairs: CalcitValue[]) => CalcitImpl;
-export declare let _$n_struct_$o__$o_new: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStruct;
-export declare let _$n_enum_$o__$o_new: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnum;
+export declare let _$n_struct_def_$o_new: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStructDef;
+export declare let _$n_enum_def_$o_new: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnumDef;
 export declare let print: (...xs: CalcitValue[]) => void;
 export declare function _$n_list_$o_count(x: CalcitValue): number;
 export declare function _$n_str_$o_count(x: CalcitValue): number;
 export declare function _$n_map_$o_count(x: CalcitValue): number;
-export declare function _$n_record_$o_count(x: CalcitValue): number;
-export declare function _$n_record_$o_field_tag(x: CalcitValue, idx: CalcitValue): CalcitTag;
-export declare function _$n_record_$o_nth(x: CalcitValue, idx: CalcitValue): CalcitValue;
+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_set_$o_count(x: CalcitValue): number;
 export declare let _$L_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _SQUO_: (...xs: CalcitValue[]) => CalcitSliceList;
@@ -101,33 +101,33 @@ export declare let _$n_str: (x: CalcitValue) => string;
 export declare let _$n_str_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
 export declare let _$n_list_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
 export declare let _$n_map_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
-export declare let _$n_record_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_struct_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
 export declare let _$n_str_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
 export declare let _$n_list_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
 export declare let _$n_map_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
 export declare let _$n_set_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
 export declare let _$n_str_$o_nth: (xs: CalcitValue, k: CalcitValue) => string;
 export declare let _$n_list_$o_nth: (xs: CalcitValue, k: CalcitValue) => CalcitValue;
-export declare let _$n_tuple_$o_nth: (xs: CalcitValue, k: CalcitValue) => CalcitValue;
-export declare let _$n_tuple_$o_count: (xs: CalcitValue) => number;
-export declare let _$n_tuple_$o_impls: (x: CalcitTuple) => CalcitSliceList;
-export declare let _$n_tuple_$o_params: (x: CalcitTuple) => CalcitSliceList;
-export declare let _$n_tuple_$o_with_impls: (x: CalcitTuple, y: CalcitValue) => CalcitTuple;
-export declare let _$n_tuple_$o_impl_traits: (x: CalcitValue, ...traits: CalcitValue[]) => CalcitTuple;
-export declare let _$n_tuple_$o_enum: (x: CalcitTuple) => CalcitEnum;
-export declare let _$n_tuple_$o_enum_has_variant_$q_: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
-export declare let _$n_tuple_$o_enum_has_variant: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
-export declare let _$n_tuple_$o_enum_variant_arity: (enumPrototype: CalcitValue, variantTag: CalcitTag) => number;
-export declare let _$n_tuple_$o_validate_enum: (tuple: CalcitValue, tag: CalcitValue) => CalcitValue;
-export declare let _$n_record_$o_get: (xs: CalcitValue, k: CalcitTag) => CalcitValue;
+export declare let _$n_enum_$o_nth: (xs: CalcitValue, k: CalcitValue) => CalcitValue;
+export declare let _$n_enum_$o_count: (xs: CalcitValue) => number;
+export declare let _$n_enum_$o_impls: (x: CalcitEnumValue) => CalcitSliceList;
+export declare let _$n_enum_$o_params: (x: CalcitEnumValue) => CalcitSliceList;
+export declare let _$n_enum_$o_with_impls: (x: CalcitEnumValue, y: CalcitValue) => CalcitEnumValue;
+export declare let _$n_enum_$o_impl_traits: (x: CalcitValue, ...traits: CalcitValue[]) => CalcitEnumValue;
+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_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_tuple_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitTuple;
+export declare let _$n_enum_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitEnumValue;
 export declare let _$n_map_$o_assoc: (xs: CalcitValue, ...args: CalcitValue[]) => CalcitMap | CalcitSliceMap;
-export declare let _$n_record_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitRecord;
-export declare let _$n_record_$o_impls: (xs: CalcitValue) => CalcitSliceList;
-export declare let _$n_record_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitRecord;
-export declare let _$n_struct_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitStruct;
-export declare let _$n_enum_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitRecord | CalcitEnum;
+export declare let _$n_struct_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitStructValue;
+export declare let _$n_struct_$o_impls: (xs: CalcitValue) => CalcitSliceList;
+export declare let _$n_struct_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitStructValue;
+export declare let _$n_struct_def_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitStructDef;
+export declare let _$n_enum_def_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitEnumDef;
 export declare let _$n_impl_$o_origin: (impl: CalcitValue) => CalcitValue;
 export declare let _$n_impl_$o_get: (impl: CalcitValue, name: CalcitValue) => CalcitValue;
 export declare let _$n_impl_$o_nth: (impl: CalcitValue, index: CalcitValue) => CalcitValue;
@@ -236,8 +236,8 @@ export declare let list_$q_: (x: CalcitValue) => boolean;
 export declare let set_$q_: (x: CalcitValue) => boolean;
 export declare let fn_$q_: (x: CalcitValue) => boolean;
 export declare let ref_$q_: (x: CalcitValue) => boolean;
-export declare let record_$q_: (x: CalcitValue) => boolean;
-export declare let tuple_$q_: (x: CalcitValue) => boolean;
+export declare let struct_$q_: (x: CalcitValue) => boolean;
+export declare let enum_$q_: (x: CalcitValue) => boolean;
 export declare let buffer_$q_: (x: CalcitValue) => boolean;
 export declare let _$n_str_$o_escape: (x: string) => string;
 export declare let read_file: (path: string) => string;
@@ -256,11 +256,11 @@ type DataShapeNode = {
     value: number;
 } | {
     kind: "struct";
-    nominal: CalcitStruct;
+    nominal: CalcitStructDef;
     fields: Array<[string, number]>;
 } | {
     kind: "enum";
-    nominal: CalcitEnum;
+    nominal: CalcitEnumDef;
     variants: Array<{
         tag: string;
         payload: number[];
@@ -284,9 +284,9 @@ export declare let js_array: (...xs: CalcitValue[]) => CalcitValue[];
 /** for..await alternative with function */
 export declare let js_for_await: (stream: AsyncIterableIterator<CalcitValue>, f: (v: CalcitValue) => Promise<CalcitValue>) => Promise<CalcitValue>;
 export declare let _$n_js_object: (...xs: CalcitValue[]) => Record<string, CalcitValue>;
-export declare let _$o__$o_: (tagName: CalcitValue, ...extra: CalcitValue[]) => CalcitTuple;
-export declare let _PCT__$o__$o_: (enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]) => CalcitTuple;
-export declare let _PCT__PCT__$o__$o_: (impl: CalcitValue, enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]) => CalcitTuple;
+export declare let _$o__$o_: (tagName: CalcitValue, ...extra: CalcitValue[]) => CalcitEnumValue;
+export declare let _PCT__$o__$o_: (enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]) => CalcitEnumValue;
+export declare let _PCT__PCT__$o__$o_: (impl: CalcitValue, enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]) => CalcitEnumValue;
 type CalcitImplEntry = CalcitImpl | CalcitList | CalcitSliceList | null;
 declare let calcit_builtin_impls: {
     number: CalcitImplEntry;
@@ -295,8 +295,8 @@ declare let calcit_builtin_impls: {
     list: CalcitImplEntry;
     map: CalcitImplEntry;
     fn: CalcitImplEntry;
-    tuple: CalcitImplEntry;
-    record: CalcitImplEntry;
+    enum: CalcitImplEntry;
+    struct: CalcitImplEntry;
     scalar: CalcitImplEntry;
 };
 export declare let register_calcit_builtin_impls: (options: typeof calcit_builtin_impls) => void;