@calcit/procs 0.12.59 → 0.13.0

package/ts-src/calcit.procs.mts

@@ -21,7 +21,7 @@ import {
   hashFunction,
 } from "./calcit-data.mjs";
 
-import { CalcitRef } from "./js-ref.mjs";
+import { CalcitRef, atom } from "./js-ref.mjs";
 import { CalcitRecord } from "./js-record.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitStruct } from "./js-struct.mjs";
@@ -50,7 +50,8 @@ 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 { to_calcit_data, extract_cirru_edn, CalcitCirruQuote } from "./js-cirru.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";
 
@@ -299,7 +300,9 @@ export let _$n_impl_$o__$o_new = (name: CalcitValue, ...pairs: CalcitValue[]): C
   let sourcePairs = pairs;
   if (pairs.length === 1 && pairs[0] instanceof CalcitImpl) {
     const sourceImpl = pairs[0];
-    sourcePairs = sourceImpl.fields.map((field, idx) => new CalcitTuple(field, [sourceImpl.values[idx]], null));
+    sourcePairs = sourceImpl.fields.map(
+      (field, idx) => new CalcitTuple(newTag(field.value), [sourceImpl.values[idx]], null)
+    );
   }
   for (let idx = 0; idx < sourcePairs.length; idx++) {
     const pairValue = sourcePairs[idx];
@@ -939,6 +942,18 @@ export let _$n_list_$o_first = (xs: CalcitValue): CalcitValue => {
   console.error(xs);
   throw new Error("Expected a list");
 };
+
+export let _$n_list_$o_last = (xs: CalcitValue): CalcitValue => {
+  if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
+    if (xs.isEmpty()) {
+      return null;
+    }
+    return xs.get(xs.len() - 1);
+  }
+  console.error(xs);
+  throw new Error("Expected a list");
+};
+
 export let _$n_str_$o_first = (xs: CalcitValue): CalcitValue => {
   if (typeof xs === "string") {
     return xs[0];
@@ -980,10 +995,10 @@ export let timeout_call = (duration: number, f: CalcitFn): null => {
   return null;
 };
 
-export let _$n_list_$o_rest = (xs: CalcitValue): CalcitValue => {
+export let _$n_list_$o_rest = (xs: CalcitValue): CalcitList | CalcitSliceList => {
   if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
     if (xs.len() === 0) {
-      return null;
+      return xs.slice(0, 0);
     }
     return xs.rest();
   }
@@ -1038,10 +1053,10 @@ export let last = (xs: CalcitValue): CalcitValue => {
   throw new Error("Data not ready for last");
 };
 
-export let butlast = (xs: CalcitValue): CalcitValue => {
+export let butlast = (xs: CalcitValue): CalcitList | CalcitSliceList | string => {
   if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
     if (xs.len() === 0) {
-      return null;
+      return xs.slice(0, 0);
     }
     return xs.slice(0, xs.len() - 1);
   }
@@ -1346,12 +1361,12 @@ export let _$n_str_$o_find_index = (x: string, y: string): number => {
   return x.indexOf(y);
 };
 
-export let parse_float = (x: string): number | null => {
-  const value = parseFloat(x);
-  if (Number.isNaN(value)) {
+export let _$n_parse_float = (x: string): number | null => {
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(x)) {
     return null;
   }
-  return value;
+  const value = Number(x);
+  return Number.isNaN(value) ? null : value;
 };
 export let trim = (x: string, c: string): string => {
   if (c != null) {
@@ -1422,7 +1437,7 @@ export let js_delete = (obj: any, name: string): any => {
   return delete obj[name];
 };
 
-export let get_env = (name: string, v0: string): string => {
+export let _$n_get_env = (name: string, v0?: CalcitValue): CalcitValue => {
   let v = undefined;
   if (inNodeJs) {
     // only available for Node.js
@@ -1436,9 +1451,14 @@ export let get_env = (name: string, v0: string): string => {
   if (v == null && v0 == null) {
     console.warn(`(get-env "${name}"): config not found`);
   }
-  return v ?? v0;
+  return v ?? v0 ?? null;
 };
 
+// Keep already-emitted JS bundles loadable across the nominal Option migration.
+// Newly generated code calls the internal raw proc; source-level `get-env`
+// remains the typed Option wrapper defined in calcit.core.
+export let get_env = _$n_get_env;
+
 export let turn_tag = (x: CalcitValue): CalcitTag => {
   if (typeof x === "string") {
     return newTag(x);
@@ -1656,6 +1676,214 @@ export let parse_cirru_edn = (code: string, options: CalcitValue) => {
   }
 };
 
+type DataShapeNode =
+  | { kind: "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" }
+  | { kind: "optional" | "list" | "set" | "ref"; inner: number }
+  | { kind: "map"; key: number; value: number }
+  | { kind: "struct"; nominal: CalcitStruct; fields: Array<[string, number]> }
+  | { kind: "enum"; nominal: CalcitEnum; variants: Array<{ tag: string; payload: number[] }> };
+
+type DataShapeGraph = {
+  version: number;
+  root: number;
+  fingerprint: string;
+  nodes: DataShapeNode[];
+};
+
+const typed_edn_kind = (value: any): string => {
+  if (value == null) return "nil";
+  if (typeof value === "boolean") return "bool";
+  if (typeof value === "number") return "number";
+  if (typeof value === "string") return "string";
+  if (value instanceof CalcitSymbol) return "symbol";
+  if (value instanceof CalcitTag) return "tag";
+  if (value instanceof CalcitList || value instanceof CalcitSliceList) return "list";
+  if (value instanceof CalcitMap || value instanceof CalcitSliceMap) 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 CalcitRef) return "atom";
+  if (value instanceof CalcitCirruQuote) return "cirru-quote";
+  if (value instanceof Uint8Array) return "buffer";
+  return "unsupported";
+};
+
+const typed_edn_error = (path: string, message: string): never => {
+  throw new Error(`parse-cirru-edn-as failed at ${path}: ${message}`);
+};
+
+const enum_prototype_name = (value: CalcitEnum | CalcitRecord): string => {
+  return value instanceof CalcitEnum ? value.name() : value.name.value;
+};
+
+const decode_typed_edn_node = (graph: DataShapeGraph, nodeId: number, input: any, path: string, depth: number): any => {
+  if (depth > 1024) typed_edn_error(path, "decode nesting exceeds 1024");
+  const node = graph.nodes[nodeId];
+  if (node == null) typed_edn_error(path, `invalid data shape node #${nodeId}`);
+
+  switch (node.kind) {
+    case "unit":
+      if (input == null) return null;
+      return typed_edn_error(path, `expected nil, 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)}`);
+    case "number":
+      if (typeof input === "number") return input;
+      return typed_edn_error(path, `expected number, got ${typed_edn_kind(input)}`);
+    case "string":
+      if (typeof input === "string") return input;
+      return typed_edn_error(path, `expected string, got ${typed_edn_kind(input)}`);
+    case "symbol":
+      if (input instanceof CalcitSymbol) return input;
+      return typed_edn_error(path, `expected symbol, got ${typed_edn_kind(input)}`);
+    case "tag":
+      if (input instanceof CalcitTag) return input;
+      return typed_edn_error(path, `expected tag, got ${typed_edn_kind(input)}`);
+    case "buffer":
+      if (input instanceof Uint8Array) return input;
+      return typed_edn_error(path, `expected buffer, got ${typed_edn_kind(input)}`);
+    case "cirru-quote":
+      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);
+    case "list": {
+      if (!(input instanceof CalcitList || input instanceof CalcitSliceList)) {
+        return typed_edn_error(path, `expected list, got ${typed_edn_kind(input)}`);
+      }
+      const values = Array.from(input.items()).map((value, idx) =>
+        decode_typed_edn_node(graph, node.inner, value, `${path}[${idx}]`, depth + 1)
+      );
+      return new CalcitSliceList(values);
+    }
+    case "set": {
+      if (!(input instanceof CalcitSet || input instanceof TypedEdnSetView)) {
+        return typed_edn_error(path, `expected set, got ${typed_edn_kind(input)}`);
+      }
+      const values: any[] = [];
+      const inputValues = input instanceof TypedEdnSetView ? input.items : input.values();
+      inputValues.forEach((value) => {
+        const itemPath = `${path}.item`;
+        const decoded = decode_typed_edn_node(graph, node.inner, value, itemPath, depth + 1);
+        if (values.some((existing) => _$n__$e_(existing, decoded))) {
+          typed_edn_error(itemPath, "duplicate decoded set value");
+        }
+        values.push(decoded);
+      });
+      return new CalcitSet(values);
+    }
+    case "map": {
+      if (!(input instanceof CalcitMap || input instanceof CalcitSliceMap)) {
+        return typed_edn_error(path, `expected map, got ${typed_edn_kind(input)}`);
+      }
+      const entries: any[] = [];
+      input.pairs().forEach(([key, value]) => {
+        const keyPath = `${path}.key`;
+        const decodedKey = decode_typed_edn_node(graph, node.key, key, keyPath, depth + 1);
+        for (let idx = 0; idx < entries.length; idx += 2) {
+          if (_$n__$e_(entries[idx], decodedKey)) {
+            typed_edn_error(keyPath, "duplicate decoded map key");
+          }
+        }
+        const decodedValue = decode_typed_edn_node(graph, node.value, value, `${path}.value`, depth + 1);
+        entries.push(decodedKey, decodedValue);
+      });
+      return new CalcitSliceMap(entries);
+    }
+    case "ref":
+      if (!(input instanceof CalcitRef)) 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.name.value !== node.nominal.name.value) {
+        return typed_edn_error(path, `expected record :${node.nominal.name.value}, got record :${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(", ")}]`
+        );
+      }
+      const decodedFields = new Map<string, CalcitValue>();
+      node.fields.forEach(([name, fieldNode]) => {
+        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.
+      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`);
+      }
+      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 decodedFields.get(field.value)!;
+      });
+      return new CalcitRecord(node.nominal.name, node.nominal.fields, values, node.nominal);
+    }
+    case "enum": {
+      if (!(input instanceof CalcitTuple) || 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);
+      if (actualEnumName !== node.nominal.name()) {
+        return typed_edn_error(path, `expected enum :${node.nominal.name()}, got enum :${actualEnumName}`);
+      }
+      if (!(input.tag instanceof CalcitTag)) {
+        return typed_edn_error(path, `enum :${node.nominal.name()} variant must be a tag`);
+      }
+      const inputTag = input.tag;
+      const variant = node.variants.find((candidate) => candidate.tag === inputTag.value);
+      if (variant == null) {
+        return typed_edn_error(path, `enum :${node.nominal.name()} has no variant :${inputTag.value}`);
+      }
+      if (variant.payload.length !== input.extra.length) {
+        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);
+    }
+    default:
+      return typed_edn_error(path, `invalid data shape node kind: ${(node as any).kind}`);
+  }
+};
+
+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 (typeof graph.fingerprint !== "string" || graph.fingerprint.length === 0) {
+    throw new Error("parse-cirru-edn-as expected a non-empty data shape fingerprint");
+  }
+  const enumOptions: CalcitValue[] = [];
+  for (const node of graph.nodes) {
+    if (node.kind === "enum") enumOptions.push(newTag(node.nominal.name()), node.nominal);
+  }
+
+  let input: any;
+  try {
+    const nodes = parse(code);
+    if (nodes.length !== 1) throw new Error(`expected EDN in a single node, got ${nodes.length}`);
+    input = extract_cirru_edn_for_typed(nodes[0], new CalcitSliceMap(enumOptions));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : `${error}`;
+    throw new Error(`parse-cirru-edn-as failed to parse Cirru EDN: ${message}`);
+  }
+  return decode_typed_edn_node(graph, graph.root, input, "$", 0) as CalcitValue;
+};
+
 const json_to_calcit = (value: any): CalcitValue => {
   if (value == null) return null;
   if (typeof value === "string") return value;

package/ts-src/js-cirru.mts

@@ -13,6 +13,7 @@ import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitRef } from "./js-ref.mjs";
 import { deepEqual } from "@calcit/ternary-tree/lib/utils.mjs";
 import { atom } from "./js-ref.mjs";
+import { TypedEdnSetView } from "./typed-edn.mjs";
 
 type CirruEdnFormat = string | CirruEdnFormat[];
 
@@ -256,7 +257,7 @@ const tag_to_string = (tag: CalcitValue): string => {
   throw new Error(`Unsupported tag for EDN: ${tag}`);
 };
 
-export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): CalcitValue => {
+const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preserveSourceEntries: boolean): any => {
   if (typeof x === "string") {
     if (x === "nil") {
       return null;
@@ -291,6 +292,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
     }
     if (x[0] === "{}") {
       let result: Array<CalcitValue> = [];
+      const sourceKeys: CirruEdnFormat[] = [];
       x.forEach((pair, idx) => {
         if (idx === 0) {
           return; // skip first `{}` symbol
@@ -298,7 +300,15 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
         if (pair instanceof Array) {
           if (pair[0] === ";") return;
           if (pair.length === 2) {
-            result.push(extract_cirru_edn(pair[0], options), extract_cirru_edn(pair[1], options));
+            const key = extract_cirru_edn_inner(pair[0], options, preserveSourceEntries);
+            const value = extract_cirru_edn_inner(pair[1], options, preserveSourceEntries);
+            const existingIdx = preserveSourceEntries ? sourceKeys.findIndex((sourceKey) => deepEqual(sourceKey, pair[0])) : -1;
+            if (existingIdx >= 0) {
+              result[(existingIdx << 1) + 1] = value;
+            } else {
+              if (preserveSourceEntries) sourceKeys.push(pair[0]);
+              result.push(key, value);
+            }
           } else {
             throw new Error(`Expected a pair, got: ${pair}`);
           }
@@ -323,7 +333,10 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
           if (pair[0] === ";") return;
           if (pair.length === 2) {
             if (typeof pair[0] === "string") {
-              entries.push([extractFieldTag(pair[0]), extract_cirru_edn(pair[1], options)]);
+              entries.push([
+                extractFieldTag(pair[0]),
+                extract_cirru_edn_inner(pair[1], options, preserveSourceEntries),
+              ]);
             } else {
               throw new Error(`Expected string as field, got: ${pair}`);
             }
@@ -348,10 +361,9 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
       if (options instanceof CalcitMap || options instanceof CalcitSliceMap) {
         let v = options.get(extractFieldTag(name));
         if (v != null && v instanceof CalcitRecord) {
-          if (!deepEqual(v.fields, fields)) {
-            throw new Error(`Fields mismatch for ${name}, expected ${fields}, got ${v.fields}`);
+          if (deepEqual(v.fields, fields)) {
+            return new CalcitRecord(extractFieldTag(name), fields, values, v.structRef);
           }
-          return new CalcitRecord(extractFieldTag(name), fields, values, v.structRef);
         }
       }
 
@@ -368,19 +380,19 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
         x
           .slice(1)
           .filter(notComment)
-          .map((x) => extract_cirru_edn(x, options))
+          .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries))
       );
     }
     if (x[0] === "#{}") {
-      return new CalcitSet(
-        x
-          .slice(1)
-          .filter(notComment)
-          .map((x) => extract_cirru_edn(x, options))
-      );
+      const sourceItems = x.slice(1).filter(notComment);
+      const uniqueSourceItems = preserveSourceEntries
+        ? sourceItems.filter((item, idx) => !sourceItems.slice(0, idx).some((existing) => deepEqual(existing, item)))
+        : sourceItems;
+      const items = uniqueSourceItems.map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries));
+      return preserveSourceEntries ? new TypedEdnSetView(items) : new CalcitSet(items);
     }
     if (x[0] === "do" && x.length === 2) {
-      return extract_cirru_edn(x[1], options);
+      return extract_cirru_edn_inner(x[1], options, preserveSourceEntries);
     }
     if (x[0] === "quote") {
       if (x.length !== 2) {
@@ -393,11 +405,11 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
         throw new Error(`tuple expects at least 1 value, got: ${x}`);
       }
       return new CalcitTuple(
-        extract_cirru_edn(x[1], options),
+        extract_cirru_edn_inner(x[1], options, preserveSourceEntries),
         x
           .slice(2)
           .filter(notComment)
-          .map((x) => extract_cirru_edn(x, options))
+          .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries))
       );
     }
     if (x[0] === "%::") {
@@ -413,11 +425,11 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
       const proto = enumPrototype != null ? unwrap_enum_prototype_local(enumPrototype) : null;
       const enumTag = proto != null ? proto.name.toString() : enumName;
       return new CalcitTuple(
-        extract_cirru_edn(x[2], options),
+        extract_cirru_edn_inner(x[2], options, preserveSourceEntries),
         x
           .slice(3)
           .filter(notComment)
-          .map((x) => extract_cirru_edn(x, options)),
+          .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries)),
         enumPrototype
       );
     }
@@ -425,13 +437,21 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
       if (x.length !== 2) {
         throw new Error(`atom expects 1 argument, got: ${x}`);
       }
-      return atom(extract_cirru_edn(x[1], options));
+      return atom(extract_cirru_edn_inner(x[1], options, preserveSourceEntries));
     }
   }
   console.error(x);
   throw new Error(`Unexpected data from EDN: ${x}`);
 };
 
+export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): CalcitValue => {
+  return extract_cirru_edn_inner(x, options, false) as CalcitValue;
+};
+
+export let extract_cirru_edn_for_typed = (x: CirruEdnFormat, options: CalcitValue): CalcitValue | TypedEdnSetView => {
+  return extract_cirru_edn_inner(x, options, true) as CalcitValue | TypedEdnSetView;
+};
+
 export let format_cirru_edn = (data: CalcitValue, useInline: boolean = true): string => {
   if (data == null) {
     return "\ndo nil" + "\n";

package/ts-src/js-impl.mts

@@ -3,6 +3,8 @@ import { CalcitValue } from "./js-primes.mjs";
 import { CalcitTag, castTag, findInFields, toString } from "./calcit-data.mjs";
 import type { CalcitTrait } from "./js-trait.mjs";
 
+const CALCIT_IMPL_BRAND = Symbol.for("@calcit/procs/CalcitImpl");
+
 export class CalcitImpl {
   name: CalcitTag;
   origin: CalcitTrait | null;
@@ -10,7 +12,38 @@ export class CalcitImpl {
   values: Array<CalcitValue>;
   cachedHash: Hash;
 
+  static [Symbol.hasInstance](value: unknown): boolean {
+    if (typeof value !== "object" || value === null) return false;
+
+    const candidate = value as Record<PropertyKey, unknown>;
+    const brand = Object.getOwnPropertyDescriptor(candidate, CALCIT_IMPL_BRAND);
+    const name = Object.getOwnPropertyDescriptor(candidate, "name");
+    const origin = Object.getOwnPropertyDescriptor(candidate, "origin");
+    const fields = Object.getOwnPropertyDescriptor(candidate, "fields");
+    const values = Object.getOwnPropertyDescriptor(candidate, "values");
+    const cachedHash = Object.getOwnPropertyDescriptor(candidate, "cachedHash");
+
+    return (
+      brand?.value === true &&
+      name !== undefined &&
+      origin !== undefined &&
+      fields !== undefined &&
+      values !== undefined &&
+      cachedHash !== undefined &&
+      typeof name.value === "object" &&
+      name.value !== null &&
+      typeof (name.value as { value?: unknown }).value === "string" &&
+      (origin.value === null || typeof origin.value === "object") &&
+      Array.isArray(fields.value) &&
+      Array.isArray(values.value)
+    );
+  }
+
   constructor(name: CalcitTag, fields: Array<CalcitTag>, values: Array<CalcitValue>, origin: CalcitTrait | null = null) {
+    // Vite can temporarily retain two copies of @calcit/procs while refreshing
+    // 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 });
     this.name = name;
     this.origin = origin;
     this.fields = fields;

package/ts-src/typed-edn.mts

@@ -0,0 +1,7 @@
+export class TypedEdnSetView {
+  readonly items: any[];
+
+  constructor(items: any[]) {
+    this.items = items;
+  }
+}