@bian-womp/spark-graph 0.1.8 → 0.1.10

package/lib/cjs/index.cjs

@@ -24,9 +24,12 @@ class Registry {
         this.serializers = new Map();
         this.coercions = new Map();
         this.asyncCoercions = new Map();
+        this.resolvedCache = new Map();
     }
     registerType(desc, opts) {
         this.types.set(desc.id, desc);
+        // Any structural change invalidates resolution cache
+        this.resolvedCache.clear();
         if (!this.serializers.has(desc.id)) {
             this.registerSerializer(desc.id, {
                 serialize: (v) => v,
@@ -83,46 +86,231 @@ class Registry {
         return this;
     }
     // Register a type coercion from one type id to another
-    registerCoercion(fromTypeId, toTypeId, convert) {
-        this.coercions.set(`${fromTypeId}->${toTypeId}`, convert);
+    registerCoercion(fromTypeId, toTypeId, convert, opts) {
+        this.coercions.set(`${fromTypeId}->${toTypeId}`, {
+            convert,
+            nonTransitive: !!opts?.nonTransitive,
+        });
+        // If both source and target have array variants, add derived array->array coercion
+        const fromArr = `${fromTypeId}[]`;
+        const toArr = `${toTypeId}[]`;
+        const arrKey = `${fromArr}->${toArr}`;
+        if (this.types.has(fromArr) && this.types.has(toArr)) {
+            if (!this.coercions.has(arrKey) && !this.asyncCoercions.has(arrKey)) {
+                this.coercions.set(arrKey, {
+                    convert: (value) => {
+                        if (Array.isArray(value))
+                            return value.map((v) => convert(v));
+                        // Best-effort: coerce single to array-of-single
+                        return [convert(value)];
+                    },
+                    nonTransitive: !!opts?.nonTransitive,
+                });
+            }
+        }
+        this.resolvedCache.clear();
         return this;
     }
     // Register an async type coercion from one type id to another
-    registerAsyncCoercion(fromTypeId, toTypeId, convertAsync) {
-        this.asyncCoercions.set(`${fromTypeId}->${toTypeId}`, convertAsync);
+    registerAsyncCoercion(fromTypeId, toTypeId, convertAsync, opts) {
+        this.asyncCoercions.set(`${fromTypeId}->${toTypeId}`, {
+            convertAsync,
+            nonTransitive: !!opts?.nonTransitive,
+        });
+        // If both source and target have array variants, add derived array->array async coercion
+        const fromArr = `${fromTypeId}[]`;
+        const toArr = `${toTypeId}[]`;
+        const arrKey = `${fromArr}->${toArr}`;
+        if (this.types.has(fromArr) && this.types.has(toArr)) {
+            if (!this.coercions.has(arrKey) && !this.asyncCoercions.has(arrKey)) {
+                this.asyncCoercions.set(arrKey, {
+                    convertAsync: async (value, signal) => {
+                        if (Array.isArray(value)) {
+                            const out = [];
+                            for (let i = 0; i < value.length; i++) {
+                                if (signal?.aborted)
+                                    throw signal.reason ?? new Error("aborted");
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                out.push(await convertAsync(value[i], signal));
+                            }
+                            return out;
+                        }
+                        return [await convertAsync(value, signal)];
+                    },
+                    nonTransitive: !!opts?.nonTransitive,
+                });
+            }
+        }
+        this.resolvedCache.clear();
         return this;
     }
     canCoerce(fromTypeId, toTypeId) {
         if (!fromTypeId || !toTypeId)
             return false;
-        if (fromTypeId === toTypeId)
-            return true;
-        const key = `${fromTypeId}->${toTypeId}`;
-        return this.coercions.has(key) || this.asyncCoercions.has(key);
+        return !!this.resolveCoercion(fromTypeId, toTypeId);
     }
     getCoercion(fromTypeId, toTypeId) {
-        if (fromTypeId === toTypeId)
-            return (v) => v;
-        return this.coercions.get(`${fromTypeId}->${toTypeId}`);
+        const resolved = this.resolveCoercion(fromTypeId, toTypeId);
+        if (!resolved)
+            return undefined;
+        if (resolved.kind === "sync")
+            return resolved.convert;
+        return undefined;
     }
     getAsyncCoercion(fromTypeId, toTypeId) {
-        if (fromTypeId === toTypeId)
+        const resolved = this.resolveCoercion(fromTypeId, toTypeId);
+        if (!resolved)
             return undefined;
-        return this.asyncCoercions.get(`${fromTypeId}->${toTypeId}`);
+        if (resolved.kind === "async")
+            return resolved.convertAsync;
+        return undefined;
     }
     // Introspection for dynamic discovery
     listCoercions() {
         const out = [];
-        for (const key of this.coercions.keys()) {
+        for (const [key, rec] of this.coercions.entries()) {
             const [from, to] = key.split("->");
-            out.push({ from, to, async: false });
+            out.push({
+                from,
+                to,
+                async: false,
+                nonTransitive: rec.nonTransitive,
+            });
         }
-        for (const key of this.asyncCoercions.keys()) {
+        for (const [key, rec] of this.asyncCoercions.entries()) {
             const [from, to] = key.split("->");
-            out.push({ from, to, async: true });
+            out.push({ from, to, async: true, nonTransitive: rec.nonTransitive });
         }
         return out;
     }
+    resolveCoercion(fromTypeId, toTypeId) {
+        const cacheKey = `${fromTypeId}->${toTypeId}`;
+        const cached = this.resolvedCache.get(cacheKey);
+        if (cached)
+            return cached;
+        if (fromTypeId === toTypeId) {
+            const res = { kind: "sync", convert: (v) => v };
+            this.resolvedCache.set(cacheKey, res);
+            return res;
+        }
+        // Direct edges (regardless of nonTransitive)
+        const directSync = this.coercions.get(cacheKey);
+        if (directSync) {
+            const res = {
+                kind: "sync",
+                convert: directSync.convert,
+            };
+            this.resolvedCache.set(cacheKey, res);
+            return res;
+        }
+        const directAsync = this.asyncCoercions.get(cacheKey);
+        if (directAsync) {
+            const res = {
+                kind: "async",
+                convertAsync: directAsync.convertAsync,
+            };
+            this.resolvedCache.set(cacheKey, res);
+            return res;
+        }
+        // Build adjacency from transitive-allowed edges only
+        const getNeighbors = (from) => {
+            const out = [];
+            for (const [key, rec] of this.coercions.entries()) {
+                if (rec.nonTransitive)
+                    continue;
+                const [src, dst] = key.split("->");
+                if (src === from)
+                    out.push({ from: src, to: dst, kind: "sync", convert: rec.convert });
+            }
+            for (const [key, rec] of this.asyncCoercions.entries()) {
+                if (rec.nonTransitive)
+                    continue;
+                const [src, dst] = key.split("->");
+                if (src === from)
+                    out.push({
+                        from: src,
+                        to: dst,
+                        kind: "async",
+                        convertAsync: rec.convertAsync,
+                    });
+            }
+            return out;
+        };
+        const betterOf = (a, b) => {
+            if (!a)
+                return true;
+            if (b.edges !== a.edges)
+                return b.edges < a.edges;
+            return b.async < a.async;
+        };
+        const best = new Map();
+        const queue = [];
+        const push = (e) => {
+            // simple insertion to keep queue roughly ordered by cost
+            let i = 0;
+            while (i < queue.length) {
+                const q = queue[i];
+                if (e.cost.edges < q.cost.edges ||
+                    (e.cost.edges === q.cost.edges && e.cost.async < q.cost.async)) {
+                    break;
+                }
+                i++;
+            }
+            queue.splice(i, 0, e);
+        };
+        push({ node: fromTypeId, cost: { edges: 0, async: 0 }, path: [] });
+        best.set(fromTypeId, { edges: 0, async: 0 });
+        while (queue.length > 0) {
+            const cur = queue.shift();
+            if (cur.node === toTypeId) {
+                // Compose
+                const hasAsync = cur.path.some((s) => s.kind === "async");
+                if (!hasAsync) {
+                    const convert = (value) => {
+                        let acc = value;
+                        for (const step of cur.path) {
+                            // all sync by construction
+                            acc = step.convert(acc);
+                        }
+                        return acc;
+                    };
+                    const res = { kind: "sync", convert };
+                    this.resolvedCache.set(cacheKey, res);
+                    return res;
+                }
+                else {
+                    const convertAsync = async (value, signal) => {
+                        let acc = value;
+                        for (const step of cur.path) {
+                            if (step.kind === "sync") {
+                                acc = step.convert(acc);
+                            }
+                            else {
+                                acc = await step.convertAsync(acc, signal);
+                            }
+                        }
+                        return acc;
+                    };
+                    const res = { kind: "async", convertAsync };
+                    this.resolvedCache.set(cacheKey, res);
+                    return res;
+                }
+            }
+            // expand neighbors
+            for (const step of getNeighbors(cur.node)) {
+                const nextCost = {
+                    edges: cur.cost.edges + 1,
+                    async: cur.cost.async + (step.kind === "async" ? 1 : 0),
+                };
+                const prev = best.get(step.to);
+                if (betterOf(prev, nextCost)) {
+                    best.set(step.to, nextCost);
+                    push({ node: step.to, cost: nextCost, path: [...cur.path, step] });
+                }
+            }
+        }
+        return undefined;
+    }
     // Enum support
     registerEnum(desc) {
         const { id, displayName, options, opts } = desc;
@@ -1331,79 +1519,89 @@ const CompositeCategory = (registry) => ({
     policy: { mode: "hybrid" },
 });
 
+// Helpers
+const asArray = (v) => Array.isArray(v) ? v : [Number(v)];
+const broadcast = (a, b) => {
+    const aa = asArray(a);
+    const bb = asArray(b);
+    if (aa.length === bb.length)
+        return [aa, bb];
+    if (aa.length === 1)
+        return [new Array(bb.length).fill(aa[0]), bb];
+    if (bb.length === 1)
+        return [aa, new Array(aa.length).fill(bb[0])];
+    const len = Math.max(aa.length, bb.length);
+    return [new Array(len).fill(aa[0] ?? 0), new Array(len).fill(bb[0] ?? 0)];
+};
+const clamp = (x, min, max) => Math.min(max, Math.max(min, x));
+const lerp = (a, b, t) => a + (b - a) * t;
+const lcg = (seed) => {
+    let s = seed >>> 0 || 1;
+    return () => (s = (s * 1664525 + 1013904223) >>> 0) / 0xffffffff;
+};
 function setupBasicGraphRegistry() {
     const registry = new Registry();
     registry.categories.register(ComputeCategory);
-    const floatType = {
+    registry.registerType({
         id: "base.float",
         validate: (v) => typeof v === "number" && !Number.isNaN(v),
-    };
-    registry.registerType(floatType);
-    registry.registerSerializer("base.float", {
-        serialize: (v) => v,
-        deserialize: (d) => Number(d),
-    });
-    const boolType = {
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
         id: "base.bool",
         validate: (v) => typeof v === "boolean",
-    };
-    const stringType = {
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
         id: "base.string",
         validate: (v) => typeof v === "string",
-    };
-    const vec3Type = {
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
         id: "base.vec3",
         validate: (v) => Array.isArray(v) &&
             v.length === 3 &&
             v.every((x) => typeof x === "number"),
-    };
-    [boolType, stringType, vec3Type, floatType].forEach((t) => {
-        registry.registerType(t, { withArray: true, arrayPickFirstDefined: true });
-        registry.registerSerializer(t.id, {
-            serialize: (v) => v,
-            deserialize: (d) => d,
-        });
+    }, { withArray: true, arrayPickFirstDefined: true });
+    // float -> vec3 : map x to [x,0,0]
+    registry.registerCoercion("base.float", "base.vec3", (v) => {
+        return [Number(v) || 0, 0, 0];
     });
-    // Helpers
-    const asArray = (v) => Array.isArray(v) ? v : [Number(v)];
-    // float[] -> vec3[] : map x to [x,0,0]
-    registry.registerCoercion("base.float[]", "base.vec3[]", (v) => {
-        const arr = asArray(v);
-        return arr.map((x) => [Number(x) || 0, 0, 0]);
+    // Async coercion variant for vec3 -> float (chunked + abortable)
+    registry.registerAsyncCoercion("base.vec3", "base.float", async (value, signal) => {
+        if (signal.aborted)
+            throw new DOMException("Aborted", "AbortError");
+        const v = value;
+        await new Promise((r) => setTimeout(r, 1000));
+        return Math.hypot(Number(v[0] ?? 0), Number(v[1] ?? 0), Number(v[2] ?? 0));
     });
-    // Async coercion variant for vec3[] -> float[] (chunked + abortable)
-    registry.registerAsyncCoercion("base.vec3[]", "base.float[]", async (value, signal) => {
-        const arr = Array.isArray(value)
-            ? value
-            : [];
-        const out = new Array(arr.length);
-        for (let i = 0; i < arr.length; i++) {
-            if (signal.aborted)
-                throw new DOMException("Aborted", "AbortError");
-            const v = arr[i] ?? [0, 0, 0];
-            await new Promise((r) => setTimeout(r, 1000));
-            out[i] = Math.hypot(Number(v[0] ?? 0), Number(v[1] ?? 0), Number(v[2] ?? 0));
-        }
-        return out;
+    registry.registerCoercion("base.bool", "base.float", (v) => (v ? 1 : 0));
+    registry.registerCoercion("base.float", "base.bool", (v) => !!v);
+    registry.registerCoercion("base.float", "base.string", (v) => String(v));
+    registry.registerCoercion("base.string", "base.float", (v) => Number(v));
+    // Enums: Math Operation
+    registry.registerEnum({
+        id: "base.enum:math.operation",
+        options: [
+            { value: 0, label: "Add" },
+            { value: 1, label: "Subtract" },
+            { value: 2, label: "Multiply" },
+            { value: 3, label: "Divide" },
+            { value: 4, label: "Min" },
+            { value: 5, label: "Max" },
+            { value: 6, label: "Modulo" },
+            { value: 7, label: "Power" },
+        ],
+    });
+    // Enums: Compare Operation
+    registry.registerEnum({
+        id: "base.enum:compare.operation",
+        options: [
+            { value: 0, label: "LessThan" },
+            { value: 1, label: "LessThanOrEqual" },
+            { value: 2, label: "GreaterThan" },
+            { value: 3, label: "GreaterThanOrEqual" },
+            { value: 4, label: "Equal" },
+            { value: 5, label: "NotEqual" },
+        ],
     });
-    const broadcast = (a, b) => {
-        const aa = asArray(a);
-        const bb = asArray(b);
-        if (aa.length === bb.length)
-            return [aa, bb];
-        if (aa.length === 1)
-            return [new Array(bb.length).fill(aa[0]), bb];
-        if (bb.length === 1)
-            return [aa, new Array(aa.length).fill(bb[0])];
-        const len = Math.max(aa.length, bb.length);
-        return [new Array(len).fill(aa[0] ?? 0), new Array(len).fill(bb[0] ?? 0)];
-    };
-    const clamp = (x, min, max) => Math.min(max, Math.max(min, x));
-    const lerp = (a, b, t) => a + (b - a) * t;
-    const lcg = (seed) => {
-        let s = seed >>> 0 || 1;
-        return () => (s = (s * 1664525 + 1013904223) >>> 0) / 0xffffffff;
-    };
     // Number
     registry.registerNode({
         id: "base.number",
@@ -1430,32 +1628,6 @@ function setupBasicGraphRegistry() {
         outputs: { Text: "base.string" },
         impl: (ins) => ({ Text: String(ins.Value) }),
     });
-    // Enums: Math Operation
-    registry.registerEnum({
-        id: "base.enum:math.operation",
-        options: [
-            { value: 0, label: "Add" },
-            { value: 1, label: "Subtract" },
-            { value: 2, label: "Multiply" },
-            { value: 3, label: "Divide" },
-            { value: 4, label: "Min" },
-            { value: 5, label: "Max" },
-            { value: 6, label: "Modulo" },
-            { value: 7, label: "Power" },
-        ],
-    });
-    // Enums: Compare Operation
-    registry.registerEnum({
-        id: "base.enum:compare.operation",
-        options: [
-            { value: 0, label: "LessThan" },
-            { value: 1, label: "LessThanOrEqual" },
-            { value: 2, label: "GreaterThan" },
-            { value: 3, label: "GreaterThanOrEqual" },
-            { value: 4, label: "Equal" },
-            { value: 5, label: "NotEqual" },
-        ],
-    });
     // Clamp
     registry.registerNode({
         id: "base.clamp",
@@ -1667,21 +1839,6 @@ function setupBasicGraphRegistry() {
     });
     return registry;
 }
-function makeBasicGraphDefinition() {
-    return {
-        nodes: [
-            { nodeId: "n1", typeId: "base.math" },
-            { nodeId: "n2", typeId: "base.math" },
-        ],
-        edges: [
-            {
-                id: "e1",
-                source: { nodeId: "n1", handle: "Result" },
-                target: { nodeId: "n2", handle: "A" },
-            },
-        ],
-    };
-}
 function registerDelayNode(registry) {
     registry.registerNode({
         id: "async.delay",
@@ -1755,6 +1912,37 @@ function registerProgressNodes(registry) {
     });
 }
 
+function makeBasicGraphDefinition() {
+    return {
+        nodes: [
+            { nodeId: "n1", typeId: "base.math" },
+            { nodeId: "n2", typeId: "base.math" },
+            // Transitivity demo nodes
+            { nodeId: "n3", typeId: "base.compare" },
+            { nodeId: "n4", typeId: "base.randomXYZs" },
+        ],
+        edges: [
+            {
+                id: "e1",
+                source: { nodeId: "n1", handle: "Result" },
+                target: { nodeId: "n2", handle: "A" },
+            },
+            // Feed n2 result to comparer A
+            {
+                id: "e2",
+                source: { nodeId: "n2", handle: "Result" },
+                target: { nodeId: "n3", handle: "A" },
+            },
+            // Transitive coercion edge: bool[] (n3.Result) -> vec3 (n4.Min)
+            // Path: bool[] -> float[] -> vec3[] -> vec3
+            {
+                id: "e3",
+                source: { nodeId: "n3", handle: "Result" },
+                target: { nodeId: "n4", handle: "Min" },
+            },
+        ],
+    };
+}
 function createSimpleGraphDef() {
     return makeBasicGraphDefinition();
 }