@calcit/procs 0.12.59 → 0.13.1

package/lib/calcit.procs.mjs

@@ -4,7 +4,7 @@ export const calcit_package_json = pkg;
 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 } 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";
@@ -31,7 +31,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";
 export let type_of = (x) => {
     if (typeof x === "string") {
@@ -256,7 +257,7 @@ 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(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];
@@ -856,6 +857,16 @@ export let _$n_list_$o_first = (xs) => {
     console.error(xs);
     throw new Error("Expected a list");
 };
+export let _$n_list_$o_last = (xs) => {
+    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) => {
     if (typeof xs === "string") {
         return xs[0];
@@ -897,7 +908,7 @@ export let timeout_call = (duration, f) => {
 export let _$n_list_$o_rest = (xs) => {
     if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
         if (xs.len() === 0) {
-            return null;
+            return xs.slice(0, 0);
         }
         return xs.rest();
     }
@@ -947,7 +958,7 @@ export let last = (xs) => {
 export let butlast = (xs) => {
     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);
     }
@@ -1234,12 +1245,12 @@ export let _$n_str_$o_slice = (xs, m, n) => {
 export let _$n_str_$o_find_index = (x, y) => {
     return x.indexOf(y);
 };
-export let parse_float = (x) => {
-    const value = parseFloat(x);
-    if (Number.isNaN(value)) {
+export let _$n_parse_float = (x) => {
+    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, c) => {
     if (c != null) {
@@ -1304,7 +1315,7 @@ export let js_set = aset;
 export let js_delete = (obj, name) => {
     return delete obj[name];
 };
-export let get_env = (name, v0) => {
+export let _$n_get_env = (name, v0) => {
     let v = undefined;
     if (inNodeJs) {
         // only available for Node.js
@@ -1319,8 +1330,12 @@ export let get_env = (name, v0) => {
     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) => {
     if (typeof x === "string") {
         return newTag(x);
@@ -1525,6 +1540,213 @@ export let parse_cirru_edn = (code, options) => {
         throw new Error(`Expected EDN in a single node, got ${nodes.length}`);
     }
 };
+const typed_edn_kind = (value) => {
+    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, 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;
+};
+const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
+    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 = [];
+            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 = [];
+            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();
+            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.kind}`);
+    }
+};
+export let parse_cirru_edn_as = (code, graph) => {
+    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 = [];
+    for (const node of graph.nodes) {
+        if (node.kind === "enum")
+            enumOptions.push(newTag(node.nominal.name()), node.nominal);
+    }
+    let input;
+    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);
+};
 const json_to_calcit = (value) => {
     if (value == null)
         return null;

package/lib/custom-formatter.mjs

@@ -2,6 +2,8 @@ import { isLiteral } from "./js-primes.mjs";
 import { CalcitSymbol, CalcitTag } from "./calcit-data.mjs";
 import { CalcitRef } from "./js-ref.mjs";
 import { CalcitRecord } from "./js-record.mjs";
+import { CalcitStruct } from "./js-struct.mjs";
+import { CalcitEnum } from "./js-enum.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitSet } from "./js-set.mjs";
@@ -149,15 +151,22 @@ export let load_console_formatter_$x_ = () => {
                         }, `${obj.len()}`), preview);
                     }
                     if (obj instanceof CalcitRecord) {
+                        let name = new CalcitSymbol(obj.name.value);
                         if (obj.structRef.impls.length > 0) {
-                            let ret = div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, span({}, "%{}"), span({ marginLeft: "6px" }, embedObject(obj.structRef.impls[0])), span({ marginLeft: "6px" }, embedObject(obj.name)), span({ marginLeft: "6px" }, `...`));
+                            let ret = div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, span({}, "%{}"), span({ marginLeft: "6px" }, embedObject(obj.structRef.impls[0])), span({ marginLeft: "6px" }, embedObject(name)), span({ marginLeft: "6px" }, `...`));
                             return ret;
                         }
                         else {
-                            let ret = div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, `%{} ${obj.name} ...`);
+                            let ret = div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%{} ", embedObject(name), " ...");
                             return ret;
                         }
                     }
+                    if (obj instanceof CalcitStruct) {
+                        return div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%struct ", embedObject(new CalcitSymbol(obj.name.value)), " ...");
+                    }
+                    if (obj instanceof CalcitEnum) {
+                        return div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%enum ", embedObject(new CalcitSymbol(obj.prototype.name.value)), " ...");
+                    }
                     if (obj instanceof CalcitTuple) {
                         if (obj.impls.length > 0) {
                             let ret = div({ marginRight: "16px" }, div({ display: "inline-block", color: hsl(300, 100, 40) }, "%::"), div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.impls[0])), div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.tag)));
@@ -200,6 +209,9 @@ export let load_console_formatter_$x_ = () => {
                     if (obj instanceof CalcitRecord) {
                         return obj.fields.length > 0;
                     }
+                    if (obj instanceof CalcitStruct || obj instanceof CalcitEnum) {
+                        return obj instanceof CalcitStruct ? obj.fields.length > 0 : obj.prototype.fields.length > 0;
+                    }
                     return false;
                 },
                 body: (obj, config) => {
@@ -255,6 +267,20 @@ export let load_console_formatter_$x_ = () => {
                         }
                         return ret;
                     }
+                    if (obj instanceof CalcitStruct) {
+                        let ret = table({ color: hsl(280, 80, 60), borderLeft: "1px solid #eee" });
+                        for (let idx = 0; idx < obj.fields.length; idx++) {
+                            ret.push(tr({}, td({ paddingLeft: "8px", verticalAlign: "top", whiteSpace: "pre", minWidth: "40px" }, embedObject(obj.fields[idx])), td({ paddingLeft: "8px" }, embedObject(obj.fieldTypes[idx]))));
+                        }
+                        return ret;
+                    }
+                    if (obj instanceof CalcitEnum) {
+                        let ret = table({ color: hsl(280, 80, 60), borderLeft: "1px solid #eee" });
+                        for (let idx = 0; idx < obj.prototype.fields.length; idx++) {
+                            ret.push(tr({}, td({ paddingLeft: "8px", verticalAlign: "top", whiteSpace: "pre", minWidth: "40px" }, embedObject(obj.prototype.fields[idx])), td({ paddingLeft: "8px" }, embedObject(obj.prototype.values[idx]))));
+                        }
+                        return ret;
+                    }
                     return null;
                 },
             },

package/lib/js-cirru.d.mts

@@ -1,6 +1,7 @@
 import { CirruWriterNode } from "@cirru/writer.ts";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitList } from "./js-list.mjs";
+import { TypedEdnSetView } from "./typed-edn.mjs";
 type CirruEdnFormat = string | CirruEdnFormat[];
 export declare class CalcitCirruQuote {
     value: CirruWriterNode[];
@@ -16,6 +17,7 @@ export declare let format_cirru_one_liner: (data: CalcitCirruQuote | CalcitList)
 /** better use string version of Cirru EDN in future */
 export declare let to_cirru_edn: (x: CalcitValue) => CirruEdnFormat;
 export declare let extract_cirru_edn: (x: CirruEdnFormat, options: CalcitValue) => CalcitValue;
+export declare let extract_cirru_edn_for_typed: (x: CirruEdnFormat, options: CalcitValue) => CalcitValue | TypedEdnSetView;
 export declare let format_cirru_edn: (data: CalcitValue, useInline?: boolean) => string;
 export declare let to_calcit_data: (x: any, noKeyword?: boolean) => CalcitValue;
 /** deep compare cirru array */

package/lib/js-cirru.mjs

@@ -11,6 +11,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";
 export class CalcitCirruQuote {
     constructor(value) {
         if (value == null) {
@@ -260,7 +261,7 @@ const tag_to_string = (tag) => {
         return tag.name.toString();
     throw new Error(`Unsupported tag for EDN: ${tag}`);
 };
-export let extract_cirru_edn = (x, options) => {
+const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
     if (typeof x === "string") {
         if (x === "nil") {
             return null;
@@ -295,6 +296,7 @@ export let extract_cirru_edn = (x, options) => {
         }
         if (x[0] === "{}") {
             let result = [];
+            const sourceKeys = [];
             x.forEach((pair, idx) => {
                 if (idx === 0) {
                     return; // skip first `{}` symbol
@@ -303,7 +305,17 @@ export let extract_cirru_edn = (x, options) => {
                     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}`);
@@ -331,7 +343,10 @@ export let extract_cirru_edn = (x, options) => {
                         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}`);
@@ -357,10 +372,9 @@ export let extract_cirru_edn = (x, options) => {
             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);
                 }
             }
             return new CalcitRecord(extractFieldTag(name), fields, values);
@@ -375,16 +389,18 @@ export let extract_cirru_edn = (x, options) => {
             return new CalcitSliceList(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) {
@@ -396,10 +412,10 @@ export let extract_cirru_edn = (x, options) => {
             if (x.length < 2) {
                 throw new Error(`tuple expects at least 1 value, got: ${x}`);
             }
-            return new CalcitTuple(extract_cirru_edn(x[1], options), x
+            return new CalcitTuple(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] === "%::") {
             if (x.length < 3) {
@@ -413,21 +429,27 @@ export let extract_cirru_edn = (x, options) => {
             // unwrap prototype to record then extract name
             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), x
+            return new CalcitTuple(extract_cirru_edn_inner(x[2], options, preserveSourceEntries), x
                 .slice(3)
                 .filter(notComment)
-                .map((x) => extract_cirru_edn(x, options)), enumPrototype);
+                .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries)), enumPrototype);
         }
         if (x[0] === "atom") {
             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, options) => {
+    return extract_cirru_edn_inner(x, options, false);
+};
+export let extract_cirru_edn_for_typed = (x, options) => {
+    return extract_cirru_edn_inner(x, options, true);
+};
 export let format_cirru_edn = (data, useInline = true) => {
     if (data == null) {
         return "\ndo nil" + "\n";

package/lib/js-enum.mjs

@@ -24,6 +24,6 @@ export class CalcitEnum {
         return new CalcitEnum(this.prototype.withImpls(nextImpls));
     }
     toString() {
-        return `(%enum :${this.prototype.name.value})`;
+        return `(%enum '${this.prototype.name.value})`;
     }
 }

package/lib/js-impl.d.mts

@@ -8,6 +8,7 @@ export declare class CalcitImpl {
     fields: Array<CalcitTag>;
     values: Array<CalcitValue>;
     cachedHash: Hash;
+    static [Symbol.hasInstance](value: unknown): boolean;
     constructor(name: CalcitTag, fields: Array<CalcitTag>, values: Array<CalcitValue>, origin?: CalcitTrait | null);
     get(k: CalcitValue): CalcitValue;
     getOrNil(k: CalcitValue): CalcitValue;

package/lib/js-impl.mjs

@@ -1,6 +1,34 @@
 import { castTag, findInFields, toString } from "./calcit-data.mjs";
+const CALCIT_IMPL_BRAND = Symbol.for("@calcit/procs/CalcitImpl");
 export class CalcitImpl {
+    static [Symbol.hasInstance](value) {
+        if (typeof value !== "object" || value === null)
+            return false;
+        const candidate = value;
+        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.value === "string" &&
+            (origin.value === null || typeof origin.value === "object") &&
+            Array.isArray(fields.value) &&
+            Array.isArray(values.value));
+    }
     constructor(name, fields, values, origin = 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/lib/js-record.mjs

@@ -64,7 +64,7 @@ export class CalcitRecord {
     }
     toString(disableJsDataWarning = false) {
         // Optimize string building using array join instead of concatenation
-        const parts = ["(%{} ", this.name.toString()];
+        const parts = ["(%{} '", this.name.value];
         for (let idx = 0; idx < this.fields.length; idx++) {
             parts.push(" (", this.fields[idx].toString(), " ", toString(this.values[idx], true, disableJsDataWarning), ")");
         }

package/lib/js-struct.mjs

@@ -24,7 +24,7 @@ export class CalcitStruct {
         if (this.fields.length !== this.fieldTypes.length) {
             throw new Error("CalcitStruct: fields and fieldTypes length mismatch");
         }
-        const parts = ["(%struct :", this.name.value];
+        const parts = ["(%struct '", this.name.value];
         for (let idx = 0; idx < this.fields.length; idx++) {
             const field = this.fields[idx];
             const fieldType = this.fieldTypes[idx];

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.12.59",
+    "version": "0.13.1",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.7.0",
@@ -16,9 +16,10 @@
         "test-rs": "cargo test -q",
         "test-fail": "cargo test -q --bin cr type_fail_",
         "test-snippets": "cargo test -q snippets::tests",
+        "check-js-runtime": "node scripts/check-js-runtime-identity.mjs",
         "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 check-agent-interface && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
+        "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
         "check-agent-interface": "cargo build --bin cr && node scripts/check-agent-interface.mjs",
         "try-all": "yarn check-all",
         "try-rs": "cargo run --bin cr -- calcit/test.cirru",

package/lib/typed-edn.d.mts

@@ -0,0 +1,4 @@
+export declare class TypedEdnSetView {
+    readonly items: any[];
+    constructor(items: any[]);
+}

package/lib/typed-edn.mjs

@@ -0,0 +1,5 @@
+export class TypedEdnSetView {
+    constructor(items) {
+        this.items = items;
+    }
+}