@bian-womp/spark-graph 0.1.1 → 0.1.3

package/lib/cjs/index.cjs

@@ -25,8 +25,44 @@ class Registry {
         this.asyncCoercions = new Map();
         this.enums = new Map();
     }
-    registerType(desc) {
+    registerType(desc, opts) {
         this.types.set(desc.id, desc);
+        if (!this.serializers.has(desc.id)) {
+            this.registerSerializer(desc.id, {
+                serialize: (v) => v,
+                deserialize: (d) => d,
+            });
+        }
+        if (opts?.withArray) {
+            const arrayId = opts.arrayId ?? `${desc.id}[]`;
+            if (!this.types.has(arrayId)) {
+                const arrayDesc = {
+                    id: arrayId,
+                    validate: (v) => Array.isArray(v) &&
+                        v.every((x) => {
+                            try {
+                                return desc.validate(x);
+                            }
+                            catch {
+                                return false;
+                            }
+                        }),
+                };
+                this.types.set(arrayId, arrayDesc);
+            }
+            this.registerCoercion(desc.id, arrayId, (value) => Array.isArray(value) ? value : [value]);
+            this.registerCoercion(arrayId, desc.id, (value) => {
+                if (!Array.isArray(value))
+                    return value;
+                if (opts.arrayPickFirstDefined) {
+                    for (const x of value)
+                        if (x !== undefined)
+                            return x;
+                    return undefined;
+                }
+                return value[0];
+            });
+        }
         return this;
     }
     registerNode(desc) {
@@ -35,6 +71,15 @@ class Registry {
     }
     registerSerializer(typeId, s) {
         this.serializers.set(typeId, s);
+        // If an array variant of this type exists and doesn't have a serializer,
+        // auto-register an array serializer that maps each element using the base serializer.
+        const arrayId = `${typeId}[]`;
+        if (this.types.has(arrayId) && !this.serializers.has(arrayId)) {
+            this.serializers.set(arrayId, {
+                serialize: (value) => Array.isArray(value) ? value.map((el) => s.serialize(el)) : value,
+                deserialize: (data) => Array.isArray(data) ? data.map((el) => s.deserialize(el)) : data,
+            });
+        }
         return this;
     }
     // Register a type coercion from one type id to another
@@ -65,6 +110,19 @@ class Registry {
             return undefined;
         return this.asyncCoercions.get(`${fromTypeId}->${toTypeId}`);
     }
+    // Introspection for dynamic discovery
+    listCoercions() {
+        const out = [];
+        for (const key of this.coercions.keys()) {
+            const [from, to] = key.split("->");
+            out.push({ from, to, async: false });
+        }
+        for (const key of this.asyncCoercions.keys()) {
+            const [from, to] = key.split("->");
+            out.push({ from, to, async: true });
+        }
+        return out;
+    }
     // Enum support
     registerEnum(enumTypeId, options, labelType, valueType) {
         const valueToLabel = new Map();
@@ -1282,53 +1340,30 @@ function setupBasicGraphRegistry() {
     const registry = new Registry();
     registry.categories.register(ComputeCategory);
     const floatType = {
-        id: "float",
+        id: "base.float",
         validate: (v) => typeof v === "number" && !Number.isNaN(v),
     };
     registry.registerType(floatType);
-    registry.registerSerializer("float", {
+    registry.registerSerializer("base.float", {
         serialize: (v) => v,
         deserialize: (d) => Number(d),
     });
     const boolType = {
-        id: "bool",
+        id: "base.bool",
         validate: (v) => typeof v === "boolean",
     };
     const stringType = {
-        id: "string",
+        id: "base.string",
         validate: (v) => typeof v === "string",
     };
     const vec3Type = {
-        id: "vec3",
+        id: "base.vec3",
         validate: (v) => Array.isArray(v) &&
             v.length === 3 &&
             v.every((x) => typeof x === "number"),
     };
-    const floatArrayType = {
-        id: "float[]",
-        validate: (v) => Array.isArray(v) && v.every((x) => typeof x === "number"),
-    };
-    const boolArrayType = {
-        id: "bool[]",
-        validate: (v) => Array.isArray(v) && v.every((x) => typeof x === "boolean"),
-    };
-    const vec3ArrayType = {
-        id: "vec3[]",
-        validate: (v) => Array.isArray(v) &&
-            v.every((x) => Array.isArray(x) &&
-                x.length === 3 &&
-                x.every((n) => typeof n === "number")),
-    };
-    [
-        boolType,
-        stringType,
-        vec3Type,
-        floatType,
-        floatArrayType,
-        boolArrayType,
-        vec3ArrayType,
-    ].forEach((t) => {
-        registry.registerType(t);
+    [boolType, stringType, vec3Type, floatType].forEach((t) => {
+        registry.registerType(t, { withArray: true, arrayPickFirstDefined: true });
         registry.registerSerializer(t.id, {
             serialize: (v) => v,
             deserialize: (d) => d,
@@ -1336,23 +1371,13 @@ function setupBasicGraphRegistry() {
     });
     // Helpers
     const asArray = (v) => Array.isArray(v) ? v : [Number(v)];
-    // Register core coercions: float <-> float[]
-    registry.registerCoercion("float", "float[]", (v) => Array.isArray(v) ? v : [Number(v)]);
-    registry.registerCoercion("float[]", "float", (v) => Array.isArray(v) ? Number(v[0] ?? 0) : Number(v));
     // float[] -> vec3[] : map x to [x,0,0]
-    registry.registerCoercion("float[]", "vec3[]", (v) => {
+    registry.registerCoercion("base.float[]", "base.vec3[]", (v) => {
         const arr = asArray(v);
         return arr.map((x) => [Number(x) || 0, 0, 0]);
     });
-    // Example async coercion: simulate expensive conversion float[] -> vec3[] by computing magnitudes
-    registry.registerCoercion("float[]", "vec3[]", (v) => {
-        // synchronous fallback; async version can be provided on edge via convertAsync
-        if (!Array.isArray(v))
-            return [];
-        return v.map((t) => Math.hypot(Number(t?.[0] ?? 0), Number(t?.[1] ?? 0), Number(t?.[2] ?? 0)));
-    });
     // Async coercion variant for vec3[] -> float[] (chunked + abortable)
-    registry.registerAsyncCoercion("vec3[]", "float[]", async (value, signal) => {
+    registry.registerAsyncCoercion("base.vec3[]", "base.float[]", async (value, signal) => {
         const arr = Array.isArray(value)
             ? value
             : [];
@@ -1386,32 +1411,32 @@ function setupBasicGraphRegistry() {
     };
     // Number
     registry.registerNode({
-        id: "number",
+        id: "base.number",
         categoryId: "compute",
-        inputs: { Value: "float" },
-        outputs: { Result: "float" },
+        inputs: { Value: "base.float" },
+        outputs: { Result: "base.float" },
         impl: (ins) => ({ Result: Number(ins.Value) }),
     });
     // Integer
     registry.registerNode({
-        id: "integer",
+        id: "base.int",
         categoryId: "compute",
-        inputs: { Value: "float" },
-        outputs: { Result: "float" },
+        inputs: { Value: "base.float" },
+        outputs: { Result: "base.float" },
         impl: (ins) => ({
             Result: Math.trunc(Number(ins.Value)),
         }),
     });
     // Number to String
     registry.registerNode({
-        id: "numberToString",
+        id: "base.numberToString",
         categoryId: "compute",
-        inputs: { Value: "float" },
-        outputs: { Text: "string" },
+        inputs: { Value: "base.float" },
+        outputs: { Text: "base.string" },
         impl: (ins) => ({ Text: String(ins.Value) }),
     });
     // Enums: Math Operation
-    registry.registerEnum("enum:math.operation", [
+    registry.registerEnum("base.enum:math.operation", [
         { value: 0, label: "Add" },
         { value: 1, label: "Subtract" },
         { value: 2, label: "Multiply" },
@@ -1420,22 +1445,22 @@ function setupBasicGraphRegistry() {
         { value: 5, label: "Max" },
         { value: 6, label: "Modulo" },
         { value: 7, label: "Power" },
-    ], "string", "float");
+    ], "base.string", "base.float");
     // Enums: Compare Operation
-    registry.registerEnum("enum:compare.operation", [
+    registry.registerEnum("base.enum:compare.operation", [
         { value: 0, label: "LessThan" },
         { value: 1, label: "LessThanOrEqual" },
         { value: 2, label: "GreaterThan" },
         { value: 3, label: "GreaterThanOrEqual" },
         { value: 4, label: "Equal" },
         { value: 5, label: "NotEqual" },
-    ], "string", "float");
+    ], "base.string", "base.float");
     // Clamp
     registry.registerNode({
-        id: "clamp",
+        id: "base.clamp",
         categoryId: "compute",
-        inputs: { Value: "float[]", Min: "float", Max: "float" },
-        outputs: { Value: "float[]" },
+        inputs: { Value: "base.float[]", Min: "base.float", Max: "base.float" },
+        outputs: { Value: "base.float[]" },
         impl: (ins) => {
             const vals = asArray(ins.Value);
             const min = Number(ins.Min ?? 0);
@@ -1445,10 +1470,14 @@ function setupBasicGraphRegistry() {
     });
     // Interpolate (lerp)
     registry.registerNode({
-        id: "interpolate",
+        id: "base.interpolate",
         categoryId: "compute",
-        inputs: { ValueA: "float[]", ValueB: "float[]", Factor: "float" },
-        outputs: { Value: "float[]" },
+        inputs: {
+            ValueA: "base.float[]",
+            ValueB: "base.float[]",
+            Factor: "base.float",
+        },
+        outputs: { Value: "base.float[]" },
         impl: (ins) => {
             const [a, b] = broadcast(ins.ValueA, ins.ValueB);
             const t = Number(ins.Factor ?? 0);
@@ -1461,18 +1490,18 @@ function setupBasicGraphRegistry() {
     });
     // Map Range (linear)
     registry.registerNode({
-        id: "mapRange",
+        id: "base.mapRange",
         categoryId: "compute",
         inputs: {
-            Mode: "string",
-            Clamp: "bool",
-            Value: "float[]",
-            FromMin: "float",
-            FromMax: "float",
-            ToMin: "float",
-            ToMax: "float",
+            Mode: "base.string",
+            Clamp: "base.bool",
+            Value: "base.float[]",
+            FromMin: "base.float",
+            FromMax: "base.float",
+            ToMin: "base.float",
+            ToMax: "base.float",
         },
-        outputs: { Value: "float[]" },
+        outputs: { Value: "base.float[]" },
         impl: (ins) => {
             const vals = asArray(ins.Value);
             const fromMin = Number(ins.FromMin ?? 0);
@@ -1492,10 +1521,14 @@ function setupBasicGraphRegistry() {
     });
     // Math (subset) - scalar version for simple examples
     registry.registerNode({
-        id: "math",
+        id: "base.math",
         categoryId: "compute",
-        inputs: { Operation: "enum:math.operation", A: "float[]", B: "float[]" },
-        outputs: { Result: "float[]" },
+        inputs: {
+            Operation: "base.enum:math.operation",
+            A: "base.float[]",
+            B: "base.float[]",
+        },
+        outputs: { Result: "base.float[]" },
         impl: (ins) => {
             // Gracefully handle missing inputs by treating them as zeros
             const a = ins.A === undefined ? [] : asArray(ins.A);
@@ -1523,10 +1556,14 @@ function setupBasicGraphRegistry() {
     });
     // Compare
     registry.registerNode({
-        id: "compare",
+        id: "base.compare",
         categoryId: "compute",
-        inputs: { Operation: "enum:compare.operation", A: "float[]", B: "float[]" },
-        outputs: { Result: "bool[]" },
+        inputs: {
+            Operation: "base.enum:compare.operation",
+            A: "base.float[]",
+            B: "base.float[]",
+        },
+        outputs: { Result: "base.bool[]" },
         impl: (ins) => {
             const [a, b] = broadcast(ins.A, ins.B);
             const op = Number(ins.Operation ?? 4) | 0; // default Equal
@@ -1544,10 +1581,10 @@ function setupBasicGraphRegistry() {
     });
     // Combine XYZ
     registry.registerNode({
-        id: "combineXYZ",
+        id: "base.compareXYZ",
         categoryId: "compute",
-        inputs: { X: "float[]", Y: "float[]", Z: "float[]" },
-        outputs: { XYZ: "vec3[]" },
+        inputs: { X: "base.float[]", Y: "base.float[]", Z: "base.float[]" },
+        outputs: { XYZ: "base.vec3[]" },
         impl: (ins) => {
             const [x, y] = broadcast(ins.X, ins.Y);
             const [xx, z] = broadcast(x, ins.Z);
@@ -1560,10 +1597,10 @@ function setupBasicGraphRegistry() {
     });
     // Separate XYZ
     registry.registerNode({
-        id: "separateXYZ",
+        id: "base.separateXYZ",
         categoryId: "compute",
-        inputs: { XYZ: "vec3[]" },
-        outputs: { X: "float[]", Y: "float[]", Z: "float[]" },
+        inputs: { XYZ: "base.vec3[]" },
+        outputs: { X: "base.float[]", Y: "base.float[]", Z: "base.float[]" },
         impl: (ins) => {
             const arr = ins.XYZ ?? [];
             const X = arr.map((v) => Number(v?.[0] ?? 0));
@@ -1574,10 +1611,10 @@ function setupBasicGraphRegistry() {
     });
     // Indices
     registry.registerNode({
-        id: "indices",
+        id: "base.indices",
         categoryId: "compute",
-        inputs: { Domain: "float" },
-        outputs: { Indices: "float[]" },
+        inputs: { Domain: "base.float" },
+        outputs: { Indices: "base.float[]" },
         impl: (ins) => {
             const n = Math.trunc(ins.Domain);
             return { Indices: Array.from({ length: n }, (_, i) => i) };
@@ -1585,10 +1622,15 @@ function setupBasicGraphRegistry() {
     });
     // Random Numbers
     registry.registerNode({
-        id: "randomNumbers",
+        id: "base.randomNumbers",
         categoryId: "compute",
-        inputs: { Domain: "float", Min: "float", Max: "float", Seed: "float" },
-        outputs: { Values: "float[]" },
+        inputs: {
+            Domain: "base.float",
+            Min: "base.float",
+            Max: "base.float",
+            Seed: "base.float",
+        },
+        outputs: { Values: "base.float[]" },
         impl: (ins) => {
             const len = Math.trunc(ins.Domain);
             const min = Number(ins.Min ?? 0);
@@ -1600,10 +1642,15 @@ function setupBasicGraphRegistry() {
     });
     // Random Vectors
     registry.registerNode({
-        id: "randomVectors",
+        id: "base.randomXYZs",
         categoryId: "compute",
-        inputs: { Domain: "float", Min: "vec3", Max: "vec3", Seed: "float" },
-        outputs: { Values: "vec3[]" },
+        inputs: {
+            Domain: "base.float",
+            Min: "base.vec3",
+            Max: "base.vec3",
+            Seed: "base.float",
+        },
+        outputs: { Values: "base.vec3[]" },
         impl: (ins) => {
             const len = Math.trunc(ins.Domain);
             const min = ins.Min ?? [0, 0, 0];
@@ -1622,8 +1669,8 @@ function setupBasicGraphRegistry() {
 function makeBasicGraphDefinition() {
     return {
         nodes: [
-            { nodeId: "n1", typeId: "math" },
-            { nodeId: "n2", typeId: "math" },
+            { nodeId: "n1", typeId: "base.math" },
+            { nodeId: "n2", typeId: "base.math" },
         ],
         edges: [
             {
@@ -1636,10 +1683,10 @@ function makeBasicGraphDefinition() {
 }
 function registerDelayNode(registry) {
     registry.registerNode({
-        id: "delay",
+        id: "async.delay",
         categoryId: "compute",
-        inputs: { x: "float", ms: "float" },
-        outputs: { out: "float" },
+        inputs: { x: "base.float", ms: "base.float" },
+        outputs: { out: "base.float" },
         impl: async (ins, ctx) => {
             const ms = Number(ins.ms ?? 200);
             const xRaw = ins.x;
@@ -1681,10 +1728,14 @@ function sleepWithAbort(ms, signal) {
 }
 function registerProgressNodes(registry) {
     registry.registerNode({
-        id: "progressWorker",
+        id: "async.progress",
         categoryId: "compute",
-        inputs: { Steps: "float", DelayMs: "float", ShouldError: "bool" },
-        outputs: { Done: "string" },
+        inputs: {
+            Steps: "base.float",
+            DelayMs: "base.float",
+            ShouldError: "base.bool",
+        },
+        outputs: { Done: "base.string" },
         impl: async (ins, ctx) => {
             const steps = Math.max(1, Math.trunc(Number(ins.Steps ?? 10)));
             const delayMs = Math.max(0, Math.trunc(Number(ins.DelayMs ?? 50)));
@@ -1715,20 +1766,20 @@ function createAsyncGraphDef() {
         nodes: [
             {
                 nodeId: "n1",
-                typeId: "math",
+                typeId: "base.math",
             },
             {
                 nodeId: "n2",
-                typeId: "delay",
+                typeId: "async.delay",
                 params: { policy: { asyncConcurrency: "queue", maxQueue: 4 } },
             },
             {
                 nodeId: "n3",
-                typeId: "separateXYZ",
+                typeId: "base.separateXYZ",
             },
             {
                 nodeId: "n4",
-                typeId: "combineXYZ",
+                typeId: "base.compareXYZ",
             },
         ],
         edges: [
@@ -1742,7 +1793,7 @@ function createAsyncGraphDef() {
                 id: "e2",
                 source: { nodeId: "n4", handle: "XYZ" },
                 target: { nodeId: "n1", handle: "A" },
-                typeId: "vec3[]",
+                typeId: "base.vec3[]",
                 // convertAsync,
             },
             {
@@ -1773,9 +1824,9 @@ function createAsyncGraphRegistry() {
 function createProgressGraphDef() {
     const def = {
         nodes: [
-            { nodeId: "steps", typeId: "number" },
-            { nodeId: "delay", typeId: "number" },
-            { nodeId: "work", typeId: "progressWorker" },
+            { nodeId: "steps", typeId: "base.number" },
+            { nodeId: "async.delay", typeId: "base.number" },
+            { nodeId: "work", typeId: "async.progress" },
         ],
         edges: [
             {
@@ -1785,7 +1836,7 @@ function createProgressGraphDef() {
             },
             {
                 id: "e2",
-                source: { nodeId: "delay", handle: "Result" },
+                source: { nodeId: "async.delay", handle: "Result" },
                 target: { nodeId: "work", handle: "DelayMs" },
             },
             // not wiring ShouldError to show manual input driven error later
@@ -1806,11 +1857,11 @@ function createValidationGraphDef() {
     // - Multi inbound to same input
     const def = {
         nodes: [
-            { nodeId: "nA", typeId: "number" },
-            { nodeId: "nB", typeId: "number" },
-            { nodeId: "nC", typeId: "math" },
-            { nodeId: "s1", typeId: "numberToString" },
-            { nodeId: "cmp", typeId: "compare" },
+            { nodeId: "nA", typeId: "base.number" },
+            { nodeId: "nB", typeId: "base.number" },
+            { nodeId: "nC", typeId: "base.math" },
+            { nodeId: "s1", typeId: "base.numberToString" },
+            { nodeId: "cmp", typeId: "base.compare" },
             // Global validation issue: unknown node type (no nodeId/edgeId in data)
             { nodeId: "bad", typeId: "unknownType" },
         ],