@calcit/procs 0.12.17 → 0.12.19

package/editing-history/202504160117-wasm-codegen-and-catalog-update.md

@@ -0,0 +1,40 @@
+# 202504160117 — 优化目录更新 + WASM codegen demo
+
+## 优化目录更新
+
+更新 `drafts/04-15-type-directed-optimization-catalog.md`：
+
+- 标记 P0、P1、P2、P5、P7 为已完成，附 commit hash
+- 标记 P3、P4 为推迟，附推迟原因
+- 更新 Scope 行：从 `TernaryTreeList<ScopePair>` 改为 `Vec<ScopePair>`
+- P5 描述更新为实际采用的 Vec 方案（而非原规划的 O(1) 方案）
+- 新增「执行记录」节替代原「推荐执行顺序」，含基准数据（836ms→718ms，~14%）
+
+## WASM codegen 实验性功能
+
+### 新增文件
+
+- `src/codegen/emit_wasm.rs` — ~440 行 WAT 代码生成器
+- `demos/wasm-demo.cirru` — 示例程序（fibo、factorial、add-two）
+- `docs/wasm-codegen.md` — 使用文档 + 未来改进路线
+
+### 修改文件
+
+- `src/codegen.rs` — 注册 `emit_wasm` 模块
+- `src/cli_args.rs` — 新增 `EmitWasmCommand`（`cr <entry> wasm`）
+- `src/bin/cr.rs` — 新增 `run_wasm_codegen` 入口
+
+### 设计要点
+
+- **纯 WAT 文本输出** — 零额外依赖，不引入 wasm-encoder 等 crate
+- **All-f64 类型策略** — 所有值统一为 f64，Bool 用 1.0/0.0
+- **支持子集** — defn、if、let、算术(&+/&-/&\*/&/)、比较(&</&>/&=)、recur、函数调用
+- **不支持** — 字符串、Record/Map/Set、method dispatch、IO、可变参数
+
+### 验证
+
+- wasmtime compile 验证 WAT 合法
+- wasmtime run 验证 fibo(10)=89、factorial(10)=3628800、add-two(3.5,2.5)=6
+- cargo test 246/246 pass
+- cargo clippy -- -D warnings clean
+- yarn check-all pass

package/editing-history/202507160207-wasm-encoder-migration.md

@@ -0,0 +1,48 @@
+# wasm-encoder 迁移：WAT 文本 → 二进制 .wasm
+
+## 概要
+
+将 WASM codegen 从手工拼接 WAT 文本字符串改为使用 `wasm-encoder` crate 直接生成二进制 `.wasm`，
+同时将测试运行时从 wasmtime CLI 替换为 Node.js 内置的 `WebAssembly` API。
+
+## 动机
+
+- wasmtime 是重量级依赖，CI 需要额外安装步骤，且跨版本 CLI 接口不稳定（v14/v25 breaking changes）
+- WAT 字符串拼接容易出错且难以调试
+- Node.js 自带 WebAssembly 运行时，零额外依赖
+
+## 关键知识点
+
+### wasm-encoder 用法
+
+- `wasm-encoder = "0.246.2"`，仅 1 个传递依赖 `leb128fmt`
+- TypeSection → FunctionSection → ExportSection → CodeSection → module.finish()
+- `F64Const` 接受 `Ieee64` 而非 `f64`，需 `Ieee64::from(val)` 包装
+- `Function::new(locals_vec)` + `instruction(&Instruction::...)` + `instruction(&Instruction::End)`
+
+### WASM block depth 追踪
+
+- `br N` 中 N 是相对深度（0 = 当前块）
+- `if` 块会增加一层嵌套，所以在 `if` 内部 `br` 到外层 `loop` 需要 depth=1
+- 解决方案：`WasmGenCtx` 添加 `block_depth` 字段，`emit_if` 时 +1，`recur` 使用 `Br(ctx.block_depth)`
+
+### 两阶段编译
+
+- 函数互调需要预知 fn_index，所以：
+  1. 第一遍：收集函数签名和索引映射 `HashMap<String, u32>`
+  2. 第二遍：编译函数体，失败的函数用 stub `[f64_const(0.0)]` 保持索引稳定
+
+### 比较运算的 i32→f64 转换
+
+- WASM 比较指令（f64.lt/gt/eq）返回 i32
+- 用 `select(1.0, 0.0, cmp_result)` 转为 f64
+- `if` 条件用 `f64.ne(val, 0.0)` 转回 i32
+
+## 修改文件
+
+- `src/codegen/emit_wasm.rs` — 完全重写
+- `scripts/test-wasm.mjs` — 新增 Node.js 测试运行器
+- `scripts/test-wasm.sh` — 简化为生成 + node 调用
+- `.github/workflows/test.yaml` — 移除 wasmtime 安装步骤
+- `Cargo.toml` / `Cargo.lock` — 添加 wasm-encoder
+- `docs/wasm-codegen.md` — 更新文档

package/editing-history/{202604132309-typeslot-enum-compile-safety.md → 2026-0413-2309-typeslot-enum-compile-safety.md}

@@ -7,22 +7,27 @@
 ## 修改的文件
 
 ### `src/calcit/type_annotation.rs`
+
 - `resolve_to_enum_with_ref()`: 新增 `TypeSlot` 分支，通过 `resolve_type_slot()` 解析绑定类型后委托
 - `matches_with_bindings()`: 双向 `Tuple/Enum` 匹配 — 原先只有 `(Tuple, Enum)` 方向，TypeSlot 解析后顺序会翻转，新增 `(Enum, Tuple)` 方向
 
 ### `src/calcit.rs`
+
 - 将 `resolve_type_slot` 加入 `pub use` 导出列表
 
 ### `src/runner/preprocess.rs`
+
 - `resolve_enum_value()`: 在 `as_struct()` 调用前增加 TypeSlot 解析（避免 `&CalcitStruct` 生命周期问题）
 - 新增 `try_rewrite_local_fn_tuple_args_to_enum_tuples()`: 对本地函数调用（如回调 `d!`）也执行 tuple→enum 自动重写
 - 主预处理 `Calcit::Local` 分支: 增加 local fn 调用的重写+类型检查（clone 避免借用冲突）
 - `try_rewrite_single_tuple_to_enum_tuple()`: 增加变体验证 — 重写后立即检查 tag 是否是 enum 的合法 variant，不合法则发出警告
 
 ### `src/bin/cr_tests/type_fail.rs`
+
 - 新增 `type_fail_type_slot_enum_invalid_variant` 测试，验证 TypeSlot 绑定的 enum 在自动重写路径下能正确检测不存在的 variant
 
 ### `calcit/type-fail/type-slot-enum-invalid-variant.cirru`
+
 - 新增测试 fixture：声明 `defenum Action`、通过 TypeSlot 绑定、调用 `takes-action $ :: :nonexistent |hello`，期望产生 variant 不存在警告
 
 ## 知识点

package/editing-history/2026-0414-1500-loose-record-syntax.md

@@ -0,0 +1,32 @@
+# 2026-04-14 15:00 — `?{}` 松散 Record 语法
+
+## 概要
+
+新增 `?{}` 松散 record 语法，允许不声明 struct 就创建 record，与 `::` 无类型 tuple 对称。
+在函数参数有 struct 类型标注时，预处理阶段自动改写为 `%{} StructDef ...`。
+
+## 改动文件
+
+| 文件 | 变更 |
+|------|------|
+| `src/calcit/proc_name.rs` | 新增 `NativeLooseRecord` proc 变体，`?{}` 序列化，类型签名 |
+| `src/data/cirru.rs` | `"?{}"` token 解析为 `Calcit::Proc(NativeLooseRecord)` |
+| `src/calcit/record.rs` | `LOOSE_RECORD_NAME`、`is_loose()`、`from_loose_pairs()` |
+| `src/builtins/records.rs` | `call_loose_record()` 运行时：验证 tag 键、排序、排重 |
+| `src/builtins.rs` | 分发 `NativeLooseRecord => call_loose_record(args)` |
+| `src/calcit.rs` | Display: 松散 record 显示为 `(?{} ...)` |
+| `src/runner/preprocess.rs` | `try_rewrite_loose_record_args_to_struct_records`、类型推断、skip core arg check |
+| `ts-src/js-record.mts` | JS 运行时 `_$q__$M_` 函数 |
+| `calcit/test-record.cirru` | `test-loose-record-rewrite` 集成测试 |
+| `docs/features/records.md` | 文档：松散 record 语法、自动改写、类型对称表 |
+
+## 性能优化
+
+- **预处理改写链合并重建**：三步改写（map→record、loose→struct、tuple→enum）原先每步都重建 `ys` (CalcitList)，优化为仅在有改写时统一重建一次，减少 CalcitList push 操作。
+- **JS 排序比较器修正**：将重复字段检测从 sort comparator 中移出（comparator 内 throw 违反排序契约），改为排序后线性扫描相邻元素，行为更可靠。
+
+## 知识点
+
+- `EdnTag::cmp` 按全局 tag 池分配顺序排序（整数 index），**不是**字典序。record 字段排序必须用 `ref_str().cmp()` 保持字母序。
+- CalcitList 基于 persistent ternary tree，`.clone()` 是 O(1) 引用计数操作。
+- Sort comparator 不应抛异常——不同排序算法对异常行为未定义。

package/editing-history/2026-0414-2259-bidir-type-check-refactor.md

@@ -0,0 +1,63 @@
+# 202604142259 — Bidirectional Type Checking Architecture Refactoring
+
+## 概要
+
+将 `src/runner/preprocess.rs`（6199 行单体文件）拆分为模块化目录结构，
+按双向类型检查（bidirectional type checking）的概念分离关注点。
+
+## 改动详情
+
+### 模块拆分
+
+`preprocess.rs` → `preprocess/` 目录模块：
+
+| 模块 | 行数 | 职责 |
+|---|---|---|
+| `mod.rs` | ~4744 | 预处理核心：符号解析、宏展开、作用域管理、特殊语法 |
+| `type_inference.rs` | ~693 | 类型合成（synthesis）：自下而上推导表达式类型 |
+| `type_checking.rs` | ~402 | 类型检查（checking）：自上而下验证参数类型 |
+| `type_rewriting.rs` | ~398 | 类型定向重写：根据期望类型重写 AST 字面量 |
+
+### 代码去重
+
+1. **统一参数重写循环** (`rewrite_args_by_expected_type`)：
+   - 原先 4 个 `try_rewrite_*_args_to_*` 函数各自包含相同的外层循环（~30 LOC × 4）
+   - 提取为泛型 `rewrite_args_by_expected_type<F>` 函数，4 个入口各只保留闭包调用
+
+2. **统一参数类型检查循环** (`check_arg_types_loop`)：
+   - 原先 `check_local_fn_call_arg_types` 和 `check_user_fn_arg_types` 共享相同的
+     zip → resolve_type_value → matches_with_bindings → gen_check_warning 模式
+   - 提取为泛型 `check_arg_types_loop<F>` 函数，包含 variadic 处理和 spread 跳过逻辑
+
+3. **统一引用节点构建** (`build_struct_ref_node` / `build_enum_ref_node`)：
+   - 原先 map→record 和 loose-record→struct 各自复制 Import vs Struct/Enum 分支
+   - 提取为共享的 `build_struct_ref_node` 和 `build_enum_ref_node` 函数
+
+### Proc 推导提取
+
+- `infer_type_from_expr` 中的 `Calcit::Proc` 分支（~100 行 match arms）
+  提取为独立的 `infer_proc_call_return_type` 函数，提高可读性
+
+## 双向类型检查映射
+
+参照 Dunfield & Krishnaswami 的框架：
+
+| 方向 | 模块 | 入口函数 |
+|---|---|---|
+| **Synthesis** (⇒) | `type_inference` | `infer_type_from_expr`, `resolve_type_value` |
+| **Checking** (⇐) | `type_checking` | `check_*_arg_types`, `check_function_return_type` |
+| **Rewriting** (结构适配) | `type_rewriting` | `try_rewrite_*` |
+| **Context** (线程局部) | `mod.rs` | `EXPECTED_FN_TYPE`, `EXPECTED_STRUCT_TYPE` |
+
+## 为后续 match 语法扩展铺路
+
+- `type_checking.rs` 的 `check_arg_types_loop` 模式可直接复用于 match 分支检查
+- `type_inference.rs` 中已有 `infer_if_return_type` 作为分支合并的模板
+- 未来只需在相应模块中添加新函数，无需修改 `mod.rs` 的核心调度
+
+## 验证
+
+- `cargo check --lib` ✅ 零警告
+- `cargo clippy --lib -- -D warnings` ✅ 零警告
+- `cargo fmt` ✅ 格式一致
+- 链接器问题（`ld: library 'System' not found`）是环境问题，非代码变更引起

package/editing-history/2026-0415-0120-match-syntax-exhaustiveness.md

@@ -0,0 +1,20 @@
+# match syntax with exhaustiveness checking
+
+## Summary
+
+Added native `match` syntax for enum pattern matching with compile-time exhaustiveness detection,
+as a safer alternative to `tag-match` macro. See `drafts/match-syntax-rfc.md` for full design.
+
+## Files modified
+
+- `src/calcit/syntax_name.rs` — `CalcitSyntax::Match`
+- `src/builtins/syntax.rs` — `syntax_match()` runtime
+- `src/builtins.rs` — dispatch entry
+- `src/runner/preprocess/mod.rs` — `preprocess_match()` with exhaustiveness
+- `src/codegen/emit_js.rs` — `gen_match_code()` JS output
+- `calcit/test-enum.cirru` — test cases
+
+## Key takeaway
+
+Cirru indentation creates pair-based `(pattern body)` children — same format as `tag-match`.
+Flat alternating format doesn't survive Cirru serialization round-trips.

package/editing-history/202604151211-record-nth-optimization.md

@@ -0,0 +1,44 @@
+# `&record:nth` — Compile-Time Record Field Index Optimization
+
+## 概述
+
+新增 `NativeRecordNth` / `&record:nth` 过程，在预处理阶段将 record 字段访问优化为 O(1) 索引访问，绕过运行时的类型分发链和二分查找。
+
+## 优化前访问路径
+
+- `(:field record)` → 重写为 `(get arg :field)` → 运行时 6 次类型判断 (`nil?` → `string?` → `map?` → `list?` → `tuple?` → `record?`) → `&record:get` → `index_of()` O(log n) 二分查找
+- `&record:get record :field` → 运行时 `index_of()` O(log n) 二分查找
+
+## 优化后访问路径
+
+当预处理阶段可以通过 `resolve_type_value` + `as_struct()` 解析出 record 的 struct 定义时：
+
+- `(:field record)` → 直接重写为 `(&record:nth record <compile-time-idx>)` → 运行时 O(1) `values[idx]`
+- `&record:get record :field` → 重写为 `(&record:nth record <compile-time-idx>)` → 运行时 O(1)
+
+## 触发条件
+
+优化仅在类型信息明确时激活：
+- record 由 `%Struct ...` 构造器在本地 `let` 中创建
+- 函数参数有显式 struct 类型的 schema 标注
+
+若类型不明，回 fallback 到原有路径，不影响运行时行为。
+
+## 修改文件
+
+1. **`src/calcit/proc_name.rs`** — 新增 `NativeRecordNth` 变体 (`&record:nth`)，签名 `(record, number) → dynamic`
+2. **`src/builtins/records.rs`** — 实现 `record_nth(xs)` 运行时函数，直接 `values[idx]` 访问
+3. **`src/builtins.rs`** — 分发表连线 `NativeRecordNth => records::record_nth`
+4. **`src/runner/preprocess/mod.rs`** — 两个重写点：
+   - Tag-call (`Calcit::Tag` as head)：解析 arg 类型后索引重写
+   - `NativeRecordGet` proc call：解析 record arg 类型后索引重写
+5. **`src/runner/preprocess/type_inference.rs`** — `infer_record_nth_type()` 根据 struct 的 `field_types[idx]` 推断返回类型
+6. **`src/runner/preprocess/type_checking.rs`** — 将 `NativeRecordNth` 加入 core arg type check 跳过列表
+7. **`src/codegen/emit_js.rs`** — JS 内联代码生成 `record.values[idx]`，无函数调用开销
+
+## 知识点
+
+- `CalcitStruct.index_of(field_str)` 在编译期使用，用字段名解析排序位置
+- `resolve_type_value()` 返回 `None` 时优化不触发，安全回退
+- JS CalcitRecord 的 `.values` 数组和 Rust 端的 `values` Vec 索引一致（均按字段名字母序排序）
+- 对于真实项目（如 respo），函数参数通常缺少 struct 类型标注，优化暂不触发；后续若 schema 推断增强，无需改动 rewrite 逻辑即可自动生效

package/editing-history/202604160131-wasm-math-and-test-integration.md

@@ -0,0 +1,28 @@
+# 202604160131 — WASM codegen 扩展: 数学函数 + 测试集成
+
+## 新增 WASM 操作
+
+- `floor` → `f64.floor`
+- `ceil` → `f64.ceil`
+- `round` → `f64.nearest`
+- `sqrt` → `f64.sqrt`
+- `identical?` → `f64.eq`
+- `sin`/`cos`/`pow` 明确报错(WASM 无对应指令)
+
+## 新增文件
+
+- `calcit/test-wasm.cirru` — 17 个纯数值函数测试(fibo, factorial, add-two, sum-range, floor, ceil, round, sqrt, rem, compare, not, let-chain, collatz-steps, gcd 等)
+- `scripts/test-wasm.sh` — WASM 验证脚本(生成 WAT → wasmtime compile → 逐函数验证返回值)
+
+## 修改文件
+
+- `src/codegen/emit_wasm.rs` — 新增 `unary_op` 辅助函数, 添加 Floor/Ceil/Round/Sqrt/Identical 分支
+- `package.json` — `check-all` 加入 `try-wasm` 步骤; 新增 `try-wasm` 脚本
+- `docs/wasm-codegen.md` — 更新支持列表、测试说明、路线图
+
+## 验证
+
+- `yarn check-all` 通过(含 compile, try-rs, try-js, try-ir, try-wasm)
+- `cargo test` 246/246 pass
+- `cargo clippy -- -D warnings` clean
+- wasmtime 逐函数验证: 17/17 assertions pass

package/lib/js-record.mjs

@@ -1,5 +1,5 @@
 import { CalcitImpl } from "./js-impl.mjs";
-import { castTag, toString, findInFields } from "./calcit-data.mjs";
+import { newTag, castTag, toString, getStringName, findInFields } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitStruct } from "./js-struct.mjs";
 export class CalcitRecord {
@@ -116,6 +116,28 @@ export let new_impl_record = (impl, name, ...fields) => {
     let structRef = new CalcitStruct(nameTag, fieldNames, new Array(fieldNames.length).fill(null), [impl]);
     return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
 };
+/** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
+ *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+export let _$q__$M_ = (...xs) => {
+    if (xs.length % 2 !== 0) {
+        throw new Error("?{} expected pairs of :field value");
+    }
+    let pairs = [];
+    for (let i = 0; i < xs.length; i += 2) {
+        pairs.push([castTag(xs[i]), xs[i + 1]]);
+    }
+    pairs.sort((a, b) => a[0].idx - b[0].idx);
+    // Check for duplicate fields after sorting
+    for (let i = 1; i < pairs.length; i++) {
+        if (pairs[i][0].idx === pairs[i - 1][0].idx) {
+            throw new Error(`?{} received duplicate field: :${getStringName(pairs[i][0])}`);
+        }
+    }
+    let fieldNames = pairs.map((p) => p[0]);
+    let values = pairs.map((p) => p[1]);
+    let looseTag = newTag("?");
+    return new CalcitRecord(looseTag, fieldNames, values);
+};
 export let fieldsEqual = (xs, ys) => {
     if (xs === ys) {
         return true; // special case, referential equal

package/lib/package.json

@@ -1,10 +1,10 @@
 {
     "name": "@calcit/procs",
-    "version": "0.12.17",
+    "version": "0.12.19",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.0.9",
-        "typescript": "^5.9.3"
+        "typescript": "^6.0.2"
     },
     "scripts": {
         "compile": "rm -rf lib && tsc",
@@ -18,12 +18,13 @@
         "test-snippets": "cargo test -q snippets::tests",
         "bench-recur-smoke": "cargo run --bin cr -- calcit/test.cirru js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
         "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-        "check-all": "yarn compile && yarn try-rs && yarn try-js && yarn try-ir",
+        "check-all": "yarn compile && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
         "try-rs": "cargo run --bin cr -- calcit/test.cirru",
         "warn-dyn-method": "cargo run --bin cr -- calcit/test.cirru --warn-dyn-method",
         "try-js-brk": "cargo run --bin cr -- calcit/test.cirru js && node --inspect-brk js-out/main.mjs",
         "try-js": "cargo run --bin cr -- calcit/test.cirru js && node js-out/main.mjs",
-        "try-ir": "cargo run --bin cr -- calcit/test.cirru js"
+        "try-ir": "cargo run --bin cr -- calcit/test.cirru js",
+        "try-wasm": "bash scripts/test-wasm.sh"
     },
     "repository": {
         "type": "git",

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@calcit/procs",
-  "version": "0.12.17",
+  "version": "0.12.19",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.0.9",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "scripts": {
     "compile": "rm -rf lib && tsc",
@@ -18,12 +18,13 @@
     "test-snippets": "cargo test -q snippets::tests",
     "bench-recur-smoke": "cargo run --bin cr -- calcit/test.cirru js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
     "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-    "check-all": "yarn compile && yarn try-rs && yarn try-js && yarn try-ir",
+    "check-all": "yarn compile && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
     "try-rs": "cargo run --bin cr -- calcit/test.cirru",
     "warn-dyn-method": "cargo run --bin cr -- calcit/test.cirru --warn-dyn-method",
     "try-js-brk": "cargo run --bin cr -- calcit/test.cirru js && node --inspect-brk js-out/main.mjs",
     "try-js": "cargo run --bin cr -- calcit/test.cirru js && node js-out/main.mjs",
-    "try-ir": "cargo run --bin cr -- calcit/test.cirru js"
+    "try-ir": "cargo run --bin cr -- calcit/test.cirru js",
+    "try-wasm": "bash scripts/test-wasm.sh"
   },
   "repository": {
     "type": "git",

package/ts-src/js-record.mts

@@ -119,6 +119,29 @@ export let new_impl_record = (impl: CalcitImpl, name: CalcitValue, ...fields: Ar
   return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
 };
 
+/** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
+ *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+export let _$q__$M_ = (...xs: Array<CalcitValue>): CalcitValue => {
+  if (xs.length % 2 !== 0) {
+    throw new Error("?{} expected pairs of :field value");
+  }
+  let pairs: Array<[CalcitTag, CalcitValue]> = [];
+  for (let i = 0; i < xs.length; i += 2) {
+    pairs.push([castTag(xs[i]), xs[i + 1]]);
+  }
+  pairs.sort((a, b) => a[0].idx - b[0].idx);
+  // Check for duplicate fields after sorting
+  for (let i = 1; i < pairs.length; i++) {
+    if (pairs[i][0].idx === pairs[i - 1][0].idx) {
+      throw new Error(`?{} received duplicate field: :${getStringName(pairs[i][0])}`);
+    }
+  }
+  let fieldNames = pairs.map((p) => p[0]);
+  let values = pairs.map((p) => p[1]);
+  let looseTag = newTag("?");
+  return new CalcitRecord(looseTag, fieldNames, values);
+};
+
 export let fieldsEqual = (xs: Array<CalcitTag>, ys: Array<CalcitTag>): boolean => {
   if (xs === ys) {
     return true; // special case, referential equal