@calcit/procs 0.28.0 → 0.29.0-alpha.10

package/lib/calcit-data.mjs

@@ -225,6 +225,9 @@ let defaultHash_struct = valueHash("struct:");
 let defaultHash_enum = valueHash("enum:");
 let defaultHash_cirru_quote = valueHash("cirru-quote:");
 let defaultHash_unknown = valueHash("unknown:");
+let defaultHash_buffer = valueHash("buffer:");
+/** Identity hashes for host values, kept outside the objects so frozen or DOM objects are never mutated. */
+let hostValueHashes = new WeakMap();
 let fnHashCounter = 0;
 let jsObjectHashCounter = 0;
 export let hashFunction = (x) => {
@@ -265,15 +268,20 @@ export let hashFunction = (x) => {
     if (typeof x === "function") {
         // method values are closures created on the fly (see invoke_method_closure);
         // hash by method name so equal methods share the same hash, matching isEqual
+        // cache in a WeakMap instead of writing onto the function, so frozen functions hash safely
+        const cachedFn = hostValueHashes.get(x);
+        if (cachedFn != null) {
+            return cachedFn;
+        }
         const methodName = x.__calcitMethodName;
         if (methodName != null) {
             let h = mergeValueHash(defaultHash_fn, methodName);
-            x[calcit_dirty_hash_key] = h;
+            hostValueHashes.set(x, h);
             return h;
         }
         fnHashCounter = fnHashCounter + 1;
         let h = mergeValueHash(defaultHash_fn, fnHashCounter);
-        x[calcit_dirty_hash_key] = h;
+        hostValueHashes.set(x, h);
         return h;
     }
     if (x instanceof CalcitRef) {
@@ -397,15 +405,28 @@ export let hashFunction = (x) => {
         base = hashCirru(base, x.value);
         return base;
     }
-    console.warn(`[warn] calcit-js has no method for hashing this: ${x}`);
-    // currently we use dirty solution here to generate a custom hash
-    // probably happening in .to-pairs of maps, putting a js object into a set
-    // better forbid this, use .to-list instead
-    let hashJsObject = defaultHash_unknown;
+    if (x instanceof Uint8Array) {
+        // Buffers are values: equal bytes must hash equally, matching native Buffer equality.
+        let base = mergeValueHash(defaultHash_buffer, x.length);
+        for (let idx = 0; idx < x.length; idx++) {
+            base = mergeValueHash(base, x[idx]);
+        }
+        return base;
+    }
+    if (typeof x === "object" || typeof x === "function") {
+        // Host values compare by identity, so they hash by identity as well.
+        let cached = hostValueHashes.get(x);
+        if (cached != null) {
+            return cached;
+        }
+        jsObjectHashCounter = jsObjectHashCounter + 1;
+        let hashHostValue = mergeValueHash(defaultHash_unknown, jsObjectHashCounter);
+        hostValueHashes.set(x, hashHostValue);
+        return hashHostValue;
+    }
+    console.warn(`[warn] calcit-js has no method for hashing this: ${String(x)}`);
     jsObjectHashCounter = jsObjectHashCounter + 1;
-    hashJsObject = mergeValueHash(hashJsObject, jsObjectHashCounter);
-    x[calcit_dirty_hash_key] = hashJsObject;
-    return hashJsObject;
+    return mergeValueHash(defaultHash_unknown, jsObjectHashCounter);
 };
 /// traverse Cirru tree to make unique hash
 let hashCirru = (base, x) => {
@@ -826,6 +847,22 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
+    if (x instanceof Uint8Array) {
+        if (!(y instanceof Uint8Array) || x.length !== y.length) {
+            return false;
+        }
+        for (let idx = 0; idx < x.length; idx++) {
+            if (x[idx] !== y[idx]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (tx === "object") {
+        // Host objects (DOM nodes, JS class instances, BufList) compare by identity;
+        // identical references were accepted at the top of this function.
+        return false;
+    }
     throw new Error("Missing handler for this type");
 };
 // overwrite internary comparator of ternary-tree

package/lib/calcit.procs.d.mts

@@ -87,7 +87,9 @@ import { CalcitSet } from "./js-set.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;
+/** Check host member shape without invoking methods or claiming their signature is verified. */
+export declare const js_cast: (value: unknown, trait: string, fields: readonly string[], methods: readonly string[]) => object;
+export declare let _$n_trait_$o__$o_new: (name: CalcitValue, methods: CalcitValue, parents?: CalcitValue) => CalcitTrait;
 export declare let _$n_assert_traits: (value: CalcitValue, traitDef: CalcitValue) => CalcitValue;
 export declare let defstruct: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStructDef;
 export declare let defenum: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnumDef;
@@ -186,6 +188,7 @@ export declare let _$n__GT_: (a: number, b: number) => boolean;
 export declare let _$n__LT_: (a: number, b: number) => boolean;
 export declare let _$n__: (a: number, b: number) => number;
 export declare let _$n__SLSH_: (a: number, b: number) => number;
+/** Truncated remainder over safe integers, matching native and WASM; the result is never `-0`. */
 export declare let _$n_number_$o_rem: (a: number, b: number) => number;
 export declare let _$n_number_$o_fits_$q_: (value: number, target: CalcitTag) => boolean;
 export declare let round_$q_: (a: number) => boolean;

package/lib/calcit.procs.mjs

@@ -104,6 +104,52 @@ export let type_of = (x) => {
     }
     throw new Error(`Unknown data ${x}`);
 };
+// The intrinsic getter reads typed-array slots across realms, ignoring a forged Symbol.toStringTag.
+const typedArrayTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get;
+/** Check host member shape without invoking methods or claiming their signature is verified. */
+export const js_cast = (value, trait, fields, methods) => {
+    const fail = (detail, cause) => {
+        const error = new TypeError(`js-cast ${trait}: ${detail}`);
+        Object.defineProperty(error, "cause", { value: cause, configurable: true });
+        throw error;
+    };
+    // Calcit objects (including Buffers) are not interchangeable with external handles.
+    // Keep the runtime's own value classification authoritative instead of another registry.
+    let host;
+    try {
+        host = value !== null && typeof value === "object"
+            && !(ArrayBuffer.isView(value) && typedArrayTag.call(value) === "Uint8Array")
+            && !(value instanceof CalcitRecur) && type_of(value).value === "js-object";
+    }
+    catch (cause) {
+        return fail("host classification failed", cause);
+    }
+    if (!host || value === null || typeof value !== "object")
+        return fail("expected a JavaScript host object");
+    for (const field of fields) {
+        let present;
+        try {
+            present = field in value;
+        }
+        catch (cause) {
+            return fail(`field ${JSON.stringify(field)} lookup failed`, cause);
+        }
+        if (!present)
+            return fail(`missing field ${JSON.stringify(field)}`);
+    }
+    for (const method of methods) {
+        let member;
+        try {
+            member = Reflect.get(value, method);
+        }
+        catch (cause) {
+            return fail(`method ${JSON.stringify(method)} lookup failed`, cause);
+        }
+        if (typeof member !== "function")
+            return fail(`method ${JSON.stringify(method)} is not callable`);
+    }
+    return value;
+};
 const list_items = (item) => {
     if (item instanceof CalcitList || item instanceof CalcitSliceList) {
         return Array.from(item.items());
@@ -161,9 +207,9 @@ const trimDataDefinitionEntries = (entries) => {
     }
     return entries.slice(start);
 };
-export let _$n_trait_$o__$o_new = function (name, methods) {
-    if (arguments.length !== 2)
-        throw new Error("&trait::new expected 2 arguments");
+export let _$n_trait_$o__$o_new = function (name, methods, parents) {
+    if (arguments.length !== 2 && arguments.length !== 3)
+        throw new Error("&trait::new expected 2 or 3 arguments");
     const items = list_items(methods);
     const methodNames = [];
     const methodTypes = [];
@@ -175,7 +221,39 @@ export let _$n_trait_$o__$o_new = function (name, methods) {
         methodNames.push(pair[0]);
         methodTypes.push(pair[1]);
     }
-    return new CalcitTrait(name, methodNames, methodTypes);
+    const requires = parents == null ? [] : list_items(parents);
+    for (const parent of requires) {
+        if (!(parent instanceof CalcitTrait)) {
+            throw new Error(`trait ${toString(name, false)}: each requires entry must be a trait, but received: ${toString(parent, true)}`);
+        }
+    }
+    const traitDef = new CalcitTrait(name, methodNames, methodTypes, requires);
+    const owners = new Map();
+    for (const reachable of traitDef.reachable()) {
+        for (const member of reachable.methods) {
+            const owner = owners.get(member.value);
+            if (owner != null && owner !== reachable) {
+                throw new Error(`member \`${member.value}\` is declared by both ${owner.name.toString()} and ${reachable.name.toString()}; keep it on one trait`);
+            }
+            owners.set(member.value, reachable);
+        }
+    }
+    return traitDef;
+};
+/** Every attached impl needs impls of all traits its origin requires on the same type. */
+let checkRequiredTraitImpls = (impls, procName) => {
+    for (const impl of impls) {
+        const origin = impl?.origin;
+        if (origin == null)
+            continue;
+        for (const required of origin.reachable()) {
+            if (required === origin)
+                continue;
+            if (!impls.some((candidate) => candidate?.origin === required)) {
+                throw new Error(`${procName}: an impl of trait ${origin.name.toString()} requires an impl of trait ${required.name.toString()} on the same type; attach one before or with it`);
+            }
+        }
+    }
 };
 export let _$n_assert_traits = function (value, traitDef) {
     if (arguments.length !== 2)
@@ -205,6 +283,10 @@ export let _$n_assert_traits = function (value, traitDef) {
     if (missing.length > 0) {
         throw new Error(`assert-traits failed: impl ${selected.name.toString()} for trait ${traitDef.name.toString()} is incomplete. Missing: ${missing.join(" ")}`);
     }
+    const unmet = traitDef.reachable().find((required) => required !== traitDef && !impls.some((impl) => impl?.origin === required));
+    if (unmet != null) {
+        throw new Error(`assert-traits failed: ${toString(value, true)} implements ${traitDef.name.toString()} but not its required trait ${unmet.name.toString()}`);
+    }
     return value;
 };
 export let defstruct = (name, ...entries) => {
@@ -597,6 +679,7 @@ export let _$n_enum_$o_impl_traits = function (x, ...traits) {
     if (!(x instanceof CalcitEnumValue))
         throw new Error("&enum:impl-traits expects an enum value");
     const impls = traits.map((trait) => coerce_impl(trait, "&enum:impl-traits"));
+    checkRequiredTraitImpls([...(x.enumPrototype?.impls ?? []), ...impls], "&enum:impl-traits");
     let proto = x.enumPrototype;
     if (proto == null) {
         const tagName = x.tag instanceof CalcitTag ? x.tag : newTag("tag");
@@ -733,6 +816,7 @@ export let _$n_struct_$o_impl_traits = function (xs, ...traits) {
     if (!(xs instanceof CalcitStructValue))
         throw new Error("&struct:impl-traits expected a struct value");
     const impls = traits.map((trait) => coerce_impl(trait, "&struct:impl-traits"));
+    checkRequiredTraitImpls(xs.structRef.impls.concat(impls), "&struct:impl-traits");
     const nextStruct = new CalcitStructDef(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(impls), xs.structRef.definitionRef);
     return new CalcitStructValue(xs.name, xs.fields, xs.values, nextStruct);
 };
@@ -743,6 +827,7 @@ export let _$n_struct_def_$o_impl_traits = function (xs, ...traits) {
         throw new Error("&struct-def:impl-traits expected a struct definition");
     const addedImpls = traits.map((trait) => coerce_impl(trait, "&struct-def:impl-traits"));
     const baseImpls = xs.impls ?? [];
+    checkRequiredTraitImpls(baseImpls.concat(addedImpls), "&struct-def:impl-traits");
     return new CalcitStructDef(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls), xs.definitionRef);
 };
 export let _$n_enum_def_$o_impl_traits = function (xs, ...traits) {
@@ -750,6 +835,7 @@ export let _$n_enum_def_$o_impl_traits = function (xs, ...traits) {
         throw new Error("&enum-def:impl-traits takes 2+ arguments");
     const addedImpls = traits.map((trait) => coerce_impl(trait, "&enum-def:impl-traits"));
     if (xs instanceof CalcitEnumDef) {
+        checkRequiredTraitImpls([...(xs.impls ?? []), ...addedImpls], "&enum-def:impl-traits");
         return xs.withImpls(addedImpls);
     }
     throw new Error("&enum-def:impl-traits expected an enum definition");
@@ -1114,8 +1200,15 @@ export let _$n__ = (a, b) => {
 export let _$n__SLSH_ = (a, b) => {
     return a / b;
 };
+/** Truncated remainder over safe integers, matching native and WASM; the result is never `-0`. */
 export let _$n_number_$o_rem = (a, b) => {
-    return a % b;
+    if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b)) {
+        throw new Error(`&number:rem requires safe integers, but received: ${toString(a, false)} ${toString(b, false)}`);
+    }
+    if (b === 0) {
+        throw new Error("&number:rem divisor must not be zero");
+    }
+    return (a % b) + 0;
 };
 export let _$n_number_$o_fits_$q_ = (value, target) => {
     if (!(target instanceof CalcitTag)) {

package/lib/js-cirru.mjs

@@ -555,7 +555,6 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
             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) => {
@@ -565,6 +564,9 @@ 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 (typeof useInline !== "boolean") {
+        throw new Error("format-cirru-edn requires a boolean inline option");
+    }
     if (data == null) {
         return "\ndo nil" + "\n";
     }
@@ -572,7 +574,7 @@ export let format_cirru_edn = (data, useInline = true) => {
         let quoted = writeCirruCode([[to_cirru_edn(data)]], { useInline: useInline }).trim();
         return "\ndo " + quoted + "\n";
     }
-    if (typeof data === "boolean") {
+    if (typeof data === "boolean" || typeof data === "number") {
         return "\ndo " + to_cirru_edn(data) + "\n";
     }
     if (data instanceof CalcitSymbol) {

package/lib/js-trait.d.mts

@@ -4,6 +4,9 @@ export declare class CalcitTrait {
     name: CalcitTag;
     methods: CalcitTag[];
     methodTypes: CalcitValue[];
-    constructor(name: CalcitValue, methods: CalcitValue[], methodTypes: CalcitValue[]);
+    requires: CalcitTrait[];
+    constructor(name: CalcitValue, methods: CalcitValue[], methodTypes: CalcitValue[], requires?: CalcitTrait[]);
+    /** This trait and every transitively required trait, each origin once. */
+    reachable(): CalcitTrait[];
     toString(disableJsDataWarning?: boolean): string;
 }

package/lib/js-trait.mjs

@@ -1,9 +1,26 @@
 import { castTag } from "./calcit-data.mjs";
 export class CalcitTrait {
-    constructor(name, methods, methodTypes) {
+    constructor(name, methods, methodTypes, requires = []) {
         this.name = castTag(name);
         this.methods = methods.map(castTag);
         this.methodTypes = methodTypes;
+        this.requires = requires;
+    }
+    /** This trait and every transitively required trait, each origin once. */
+    reachable() {
+        const output = [];
+        const visit = (current, active) => {
+            if (active.includes(current)) {
+                throw new Error(`trait requires cycle: ${[...active, current].map((item) => item.name.toString()).join(" -> ")}`);
+            }
+            if (output.includes(current))
+                return;
+            for (const required of current.requires)
+                visit(required, [...active, current]);
+            output.push(current);
+        };
+        visit(this, []);
+        return output;
     }
     toString(disableJsDataWarning = false) {
         const parts = ["(trait ", this.name.toString()];

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.28.0",
+    "version": "0.29.0-alpha.10",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.28.0",
+  "version": "0.29.0-alpha.10",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",