@bian-womp/spark-graph 0.3.88 → 0.3.89

package/lib/src/misc/base.js

@@ -0,0 +1,1091 @@
+import { GraphBuilder } from "../builder/GraphBuilder";
+import { Registry } from "../builder/Registry";
+import { ComputeCategory } from "../plugins/compute";
+// 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 asBoolArray = (v) => (Array.isArray(v) ? v.map((x) => Boolean(x)) : [Boolean(v)]);
+const broadcastBool = (a, b) => {
+    const aa = asBoolArray(a);
+    const bb = asBoolArray(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] ?? false), new Array(len).fill(bb[0] ?? false)];
+};
+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;
+};
+// JSON Pointer helpers (RFC 6901 subset)
+function jsonPointerGet(obj, pointer) {
+    if (!pointer || pointer === "/")
+        return obj;
+    if (!pointer.startsWith("/"))
+        return undefined;
+    const parts = pointer
+        .split("/")
+        .slice(1)
+        .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    let cur = obj;
+    for (const key of parts) {
+        if (cur === undefined || cur === null)
+            return undefined;
+        cur = cur[key];
+    }
+    return cur;
+}
+function jsonPointerSet(obj, pointer, value) {
+    if (!pointer || pointer === "/")
+        return value;
+    if (!pointer.startsWith("/"))
+        return obj;
+    const parts = pointer
+        .split("/")
+        .slice(1)
+        .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    const root = structuredClone(obj);
+    let cur = root;
+    for (let i = 0; i < parts.length; i++) {
+        const key = parts[i];
+        if (i === parts.length - 1) {
+            if (Array.isArray(cur) && key === "-")
+                cur.push(value);
+            else
+                cur[key] = value;
+        }
+        else {
+            const next = cur[key];
+            if (next === undefined || next === null) {
+                // create container heuristically
+                const nextKey = parts[i + 1];
+                cur[key] = typeof nextKey === "string" && /^[0-9]+$/.test(nextKey) ? [] : {};
+            }
+            cur = cur[key];
+        }
+    }
+    return root;
+}
+function jsonPointerRemove(obj, pointer) {
+    if (!pointer || pointer === "/")
+        return undefined;
+    if (!pointer.startsWith("/"))
+        return obj;
+    const parts = pointer
+        .split("/")
+        .slice(1)
+        .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    const root = structuredClone(obj);
+    let cur = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (cur === undefined || cur === null)
+            return root;
+        cur = cur[key];
+    }
+    const last = parts[parts.length - 1];
+    if (Array.isArray(cur)) {
+        const idx = last === "-" ? cur.length - 1 : Number(last);
+        if (Number.isFinite(idx))
+            cur.splice(idx, 1);
+    }
+    else if (cur && typeof cur === "object") {
+        delete cur[last];
+    }
+    return root;
+}
+function deepMerge(a, b) {
+    if (Array.isArray(a) && Array.isArray(b))
+        return [...a, ...b];
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const out = { ...a };
+        for (const [k, v] of Object.entries(b)) {
+            out[k] = k in out ? deepMerge(out[k], v) : v;
+        }
+        return out;
+    }
+    return b;
+}
+// JSON helpers
+const isPlainObject = (v) => {
+    if (v === null || typeof v !== "object")
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+};
+const isJson = (v) => {
+    if (v === null)
+        return true;
+    const t = typeof v;
+    if (t === "string" || t === "number" || t === "boolean")
+        return true;
+    if (Array.isArray(v))
+        return v.every(isJson);
+    if (isPlainObject(v))
+        return Object.values(v).every(isJson);
+    return false;
+};
+// Export operation constants for use in examples and tests
+export const BaseMathOperation = {
+    Add: 0,
+    Subtract: 1,
+    Multiply: 2,
+    Divide: 3,
+    Min: 4,
+    Max: 5,
+    Modulo: 6,
+    Power: 7,
+    Round: 8,
+    Floor: 9,
+    Ceil: 10,
+    Abs: 11,
+    Sum: 12,
+    Avg: 13,
+    MinAll: 14,
+    MaxAll: 15,
+    Sin: 16,
+    Cos: 17,
+    Tan: 18,
+    Asin: 19,
+    Acos: 20,
+    Atan: 21,
+    Sqrt: 22,
+    Exp: 23,
+    Log: 24,
+};
+export const BaseCompareOperation = {
+    LessThan: 0,
+    LessThanOrEqual: 1,
+    GreaterThan: 2,
+    GreaterThanOrEqual: 3,
+    Equal: 4,
+    NotEqual: 5,
+};
+export const BaseLogicOperation = {
+    Not: 0,
+    And: 1,
+    Or: 2,
+    Xor: 3,
+};
+export function setupBasicGraphRegistry(id) {
+    const registry = new Registry(id);
+    registry.categories.register(ComputeCategory);
+    registry.registerType({
+        id: "base.float",
+        validate: (v) => typeof v === "number" && !Number.isNaN(v),
+        bakeTarget: { nodeTypeId: "base.input.number", inputHandle: "Value" },
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
+        id: "base.bool",
+        validate: (v) => typeof v === "boolean",
+        bakeTarget: { nodeTypeId: "base.input.bool", inputHandle: "Value" },
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
+        id: "base.string",
+        validate: (v) => typeof v === "string",
+        bakeTarget: { nodeTypeId: "base.input.string", inputHandle: "Value" },
+    }, { withArray: true, arrayPickFirstDefined: true });
+    // Generic object value (JSON-compatible; object/array/primitive/null)
+    registry.registerType({
+        id: "base.object",
+        validate: (v) => isJson(v),
+        bakeTarget: { nodeTypeId: "base.input.object", inputHandle: "Value" },
+    }, { withArray: false });
+    registry.registerType({
+        id: "base.vec3",
+        validate: (v) => Array.isArray(v) && v.length === 3 && v.every((x) => typeof x === "number"),
+        bakeTarget: { nodeTypeId: "base.input.vec3", inputHandle: "Value" },
+    }, { 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];
+    });
+    registry.registerCoercion("base.vec3", "base.float", (value) => {
+        const v = value;
+        return Math.hypot(Number(v[0] ?? 0), Number(v[1] ?? 0), Number(v[2] ?? 0));
+    });
+    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));
+    // Object <-> String
+    registry.registerCoercion("base.string", "base.object", (v) => {
+        return v;
+    });
+    registry.registerCoercion("base.object", "base.string", (v) => {
+        if (typeof v === "string")
+            return v;
+        return undefined;
+    });
+    registry.registerCoercion("base.bool", "base.object", (v) => {
+        return v;
+    });
+    registry.registerCoercion("base.object", "base.bool", (v) => {
+        if (typeof v === "boolean")
+            return v;
+        return undefined;
+    });
+    registry.registerCoercion("base.float", "base.object", (v) => {
+        return v;
+    });
+    registry.registerCoercion("base.object", "base.float", (v) => {
+        if (typeof v === "number")
+            return v;
+        return undefined;
+    });
+    registry.registerCoercion("base.vec3", "base.object", (v) => {
+        return v;
+    });
+    registry.registerCoercion("base.object", "base.vec3", (v) => {
+        try {
+            if (Array.isArray(v) && v.length === 3 && v.every((x) => typeof x === "number")) {
+                return v;
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    });
+    // Enums: Math Operation
+    registry.registerEnum({
+        id: "enum:base.math.operation",
+        options: Object.entries(BaseMathOperation).map(([label, value]) => ({
+            value,
+            label,
+        })),
+    });
+    // Enums: Compare Operation
+    registry.registerEnum({
+        id: "enum:base.compare.operation",
+        options: Object.entries(BaseCompareOperation).map(([label, value]) => ({
+            value,
+            label,
+        })),
+    });
+    // Enums: Logic Operation
+    registry.registerEnum({
+        id: "enum:base.logic.operation",
+        options: Object.entries(BaseLogicOperation).map(([label, value]) => ({
+            value,
+            label,
+        })),
+    });
+    // Number
+    registry.registerNode({
+        id: "base.input.number",
+        categoryId: "compute",
+        inputs: { Value: "base.float" },
+        outputs: { Result: "base.float" },
+        policy: { autoRun: true },
+        impl: (ins) => ({ Result: Number(ins.Value) }),
+    });
+    registry.registerNode({
+        id: "base.input.string",
+        categoryId: "compute",
+        inputs: { Value: "base.string" },
+        outputs: { Result: "base.string" },
+        policy: { autoRun: true },
+        impl: (ins) => ({ Result: String(ins.Value) }),
+    });
+    registry.registerNode({
+        id: "base.input.bool",
+        categoryId: "compute",
+        inputs: { Value: "base.bool" },
+        outputs: { Result: "base.bool" },
+        policy: { autoRun: true },
+        impl: (ins) => ({ Result: Boolean(ins.Value) }),
+    });
+    registry.registerNode({
+        id: "base.input.object",
+        categoryId: "compute",
+        inputs: { Value: "base.object" },
+        outputs: { Result: "base.object" },
+        policy: { autoRun: true },
+        impl: (ins) => ({ Result: ins.Value }),
+    });
+    registry.registerNode({
+        id: "base.input.vec3",
+        categoryId: "compute",
+        inputs: { Value: "base.vec3" },
+        outputs: { Result: "base.vec3" },
+        policy: { autoRun: true },
+        impl: (ins) => ({ Result: ins.Value }),
+    });
+    // JSON parser node: base.stringToObject
+    registry.registerNode({
+        id: "base.string.toObject",
+        categoryId: "compute",
+        inputs: { Text: "base.string" },
+        outputs: { Object: "base.object" },
+        impl: (ins) => {
+            const t = ins.Text ?? "";
+            try {
+                const obj = JSON.parse(t);
+                return { Object: obj };
+            }
+            catch {
+                return { Object: undefined };
+            }
+        },
+    });
+    registry.registerNode({
+        id: "base.object.toString",
+        categoryId: "compute",
+        inputs: { Object: "base.object" },
+        outputs: { Text: "base.string" },
+        impl: (ins) => {
+            return { Text: JSON.stringify(ins.Object) };
+        },
+    });
+    // Clamp
+    registry.registerNode({
+        id: "base.clamp",
+        categoryId: "compute",
+        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);
+            const max = Number(ins.Max ?? 1);
+            return { Value: vals.map((v) => clamp(Number(v), min, max)) };
+        },
+    });
+    // Interpolate (lerp)
+    registry.registerNode({
+        id: "base.interpolate",
+        categoryId: "compute",
+        inputs: {
+            ValueA: "base.float[]",
+            ValueB: "base.float[]",
+            Factor: "base.float",
+        },
+        outputs: { Value: "base.float[]" },
+        inputDefaults: {
+            Factor: 0.5,
+        },
+        impl: (ins) => {
+            const [a, b] = broadcast(ins.ValueA, ins.ValueB);
+            const t = Number(ins.Factor ?? 0);
+            const len = Math.max(a.length, b.length);
+            const out = new Array(len).fill(0).map((_, i) => lerp(Number(a[i] ?? 0), Number(b[i] ?? 0), t));
+            return { Value: out };
+        },
+    });
+    // Map Range (linear)
+    registry.registerNode({
+        id: "base.mapRange",
+        categoryId: "compute",
+        inputs: {
+            Mode: "base.string",
+            Clamp: "base.bool",
+            Value: "base.float[]",
+            FromMin: "base.float",
+            FromMax: "base.float",
+            ToMin: "base.float",
+            ToMax: "base.float",
+        },
+        outputs: { Value: "base.float[]" },
+        impl: (ins) => {
+            const vals = asArray(ins.Value);
+            const fromMin = Number(ins.FromMin ?? 0);
+            const fromMax = Number(ins.FromMax ?? 1);
+            const toMin = Number(ins.ToMin ?? 0);
+            const toMax = Number(ins.ToMax ?? 1);
+            const doClamp = Boolean(ins.Clamp);
+            const out = vals.map((v) => {
+                const t = (Number(v) - fromMin) / (fromMax - fromMin || 1);
+                const r = toMin + t * (toMax - toMin);
+                return doClamp ? clamp(r, Math.min(toMin, toMax), Math.max(toMin, toMax)) : r;
+            });
+            return { Value: out };
+        },
+    });
+    // Math (subset) - scalar version for simple examples
+    registry.registerNode({
+        id: "base.math",
+        categoryId: "compute",
+        inputs: {
+            Operation: "enum:base.math.operation",
+            A: "base.float[]",
+            B: "base.float[]",
+        },
+        outputs: { Result: "base.float[]" },
+        // Registry-level defaults: Add by default, A=[1], B=[1]
+        inputDefaults: { Operation: 0, A: [1], B: [1] },
+        impl: (ins) => {
+            const a = asArray(ins.A ?? []);
+            const b = asArray(ins.B ?? []);
+            const op = Number(ins.Operation ?? BaseMathOperation.Add);
+            const unaryByOp = {
+                [BaseMathOperation.Round]: (x) => Math.round(x),
+                [BaseMathOperation.Floor]: (x) => Math.floor(x),
+                [BaseMathOperation.Ceil]: (x) => Math.ceil(x),
+                [BaseMathOperation.Abs]: (x) => Math.abs(x),
+                [BaseMathOperation.Sin]: (x) => Math.sin(x),
+                [BaseMathOperation.Cos]: (x) => Math.cos(x),
+                [BaseMathOperation.Tan]: (x) => Math.tan(x),
+                [BaseMathOperation.Asin]: (x) => Math.asin(x),
+                [BaseMathOperation.Acos]: (x) => Math.acos(x),
+                [BaseMathOperation.Atan]: (x) => Math.atan(x),
+                [BaseMathOperation.Sqrt]: (x) => Math.sqrt(x),
+                [BaseMathOperation.Exp]: (x) => Math.exp(x),
+                [BaseMathOperation.Log]: (x) => Math.log(x),
+            };
+            if (unaryByOp[op])
+                return { Result: a.map((x) => unaryByOp[op](Number(x))) };
+            const aggregateByOp = {
+                [BaseMathOperation.Sum]: (arr) => arr.reduce((s, x) => s + Number(x || 0), 0),
+                [BaseMathOperation.Avg]: (arr) => {
+                    const sum = arr.reduce((s, x) => s + Number(x || 0), 0);
+                    return arr.length ? sum / arr.length : 0;
+                },
+                [BaseMathOperation.MinAll]: (arr) => (arr.length ? Math.min(...arr.map((x) => Number(x))) : 0),
+                [BaseMathOperation.MaxAll]: (arr) => (arr.length ? Math.max(...arr.map((x) => Number(x))) : 0),
+            };
+            if (aggregateByOp[op] !== undefined)
+                return { Result: [aggregateByOp[op](a)] };
+            const binaryByOp = {
+                [BaseMathOperation.Add]: (x, y) => x + y,
+                [BaseMathOperation.Subtract]: (x, y) => x - y,
+                [BaseMathOperation.Multiply]: (x, y) => x * y,
+                [BaseMathOperation.Divide]: (x, y) => x / (y || 1),
+                [BaseMathOperation.Min]: (x, y) => Math.min(x, y),
+                [BaseMathOperation.Max]: (x, y) => Math.max(x, y),
+                [BaseMathOperation.Modulo]: (x, y) => (y ? x % y : 0),
+                [BaseMathOperation.Power]: (x, y) => Math.pow(x, y),
+            };
+            const fn = binaryByOp[op] || binaryByOp[BaseMathOperation.Add];
+            const len = Math.max(a.length, b.length);
+            const out = new Array(len).fill(0).map((_, i) => {
+                const ax = a.length === 1 && len > 1 ? a[0] : (a[i] ?? 0);
+                const bx = b.length === 1 && len > 1 ? b[0] : (b[i] ?? 0);
+                return fn(Number(ax), Number(bx));
+            });
+            return { Result: out };
+        },
+    });
+    // Compare
+    registry.registerNode({
+        id: "base.compare",
+        categoryId: "compute",
+        inputs: {
+            Operation: "enum:base.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 ?? BaseCompareOperation.Equal);
+            const compareByOp = {
+                [BaseCompareOperation.LessThan]: (x, y) => x < y,
+                [BaseCompareOperation.LessThanOrEqual]: (x, y) => x <= y,
+                [BaseCompareOperation.GreaterThan]: (x, y) => x > y,
+                [BaseCompareOperation.GreaterThanOrEqual]: (x, y) => x >= y,
+                [BaseCompareOperation.Equal]: (x, y) => x === y,
+                [BaseCompareOperation.NotEqual]: (x, y) => x !== y,
+            };
+            const fn = compareByOp[op] || compareByOp[BaseCompareOperation.Equal];
+            return { Result: a.map((x, i) => fn(Number(x), Number(b[i] ?? 0))) };
+        },
+    });
+    // Logic
+    registry.registerNode({
+        id: "base.logic",
+        categoryId: "compute",
+        inputs: {
+            Operation: "enum:base.logic.operation",
+            A: "base.bool[]",
+            B: "base.bool[]",
+        },
+        outputs: { Result: "base.bool[]" },
+        inputDefaults: { Operation: BaseLogicOperation.Not },
+        impl: (ins) => {
+            const op = Number(ins.Operation ?? BaseLogicOperation.Not);
+            if (op === BaseLogicOperation.Not) {
+                const a = asBoolArray(ins.A ?? []);
+                return { Result: a.map((x) => !x) };
+            }
+            const [a, b] = broadcastBool(ins.A ?? [], ins.B ?? []);
+            const logicByOp = {
+                [BaseLogicOperation.And]: (x, y) => x && y,
+                [BaseLogicOperation.Or]: (x, y) => x || y,
+                [BaseLogicOperation.Xor]: (x, y) => Boolean(x ? !y : y),
+            };
+            const fn = logicByOp[op] || logicByOp[BaseLogicOperation.And];
+            return {
+                Result: a.map((x, i) => fn(Boolean(x), Boolean(b[i] ?? false))),
+            };
+        },
+    });
+    // Strings
+    registry.registerNode({
+        id: "base.string.length",
+        categoryId: "compute",
+        inputs: { Text: "base.string" },
+        outputs: { Length: "base.float" },
+        impl: (ins) => ({
+            Length: String(ins.Text || "").length,
+        }),
+    });
+    registry.registerNode({
+        id: "base.string.op",
+        categoryId: "compute",
+        inputs: { Op: "base.string", Text: "base.string" },
+        outputs: { Text: "base.string" },
+        impl: (ins) => {
+            const op = String(ins.Op || "trim").toLowerCase();
+            const t = String(ins.Text || "");
+            if (op === "lower")
+                return { Text: t.toLowerCase() };
+            if (op === "upper")
+                return { Text: t.toUpperCase() };
+            return { Text: t.trim() };
+        },
+    });
+    registry.registerNode({
+        id: "base.string.split",
+        categoryId: "compute",
+        inputs: { Text: "base.string", Sep: "base.string" },
+        outputs: { Parts: "base.string[]" },
+        impl: (ins) => {
+            const t = String(ins.Text || "");
+            const sep = String(ins.Sep || ",");
+            return { Parts: t.split(sep) };
+        },
+    });
+    registry.registerNode({
+        id: "base.string.join",
+        categoryId: "compute",
+        inputs: { Parts: "base.string[]", Sep: "base.string" },
+        outputs: { Text: "base.string" },
+        impl: (ins) => {
+            const parts = Array.isArray(ins.Parts) ? ins.Parts.map(String) : [];
+            const sep = String(ins.Sep || "");
+            return { Text: parts.join(sep) };
+        },
+    });
+    registry.registerNode({
+        id: "base.string.replace",
+        categoryId: "compute",
+        inputs: {
+            Text: "base.string",
+            Search: "base.string",
+            Replace: "base.string",
+        },
+        outputs: { Text: "base.string" },
+        impl: (ins) => {
+            const t = String(ins.Text || "");
+            const s = String(ins.Search || "");
+            const r = String(ins.Replace || "");
+            return { Text: t.split(s).join(r) };
+        },
+    });
+    // Arrays (carried as base.object)
+    registry.registerNode({
+        id: "base.array.length",
+        categoryId: "compute",
+        inputs: { Items: "base.object" },
+        outputs: { Length: "base.float" },
+        impl: (ins) => ({
+            Length: Array.isArray(ins.Items) ? ins.Items.length : 0,
+        }),
+    });
+    registry.registerNode({
+        id: "base.array.slice",
+        categoryId: "compute",
+        inputs: { Items: "base.object", Start: "base.float", End: "base.float" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Items) ? ins.Items : [];
+            const s = Math.trunc(Number(ins.Start ?? 0));
+            const e = Number.isFinite(Number(ins.End)) ? Math.trunc(Number(ins.End)) : undefined;
+            return { Result: arr.slice(s, e) };
+        },
+    });
+    // Compose array from dynamic item inputs
+    registry.registerNode({
+        id: "base.array.compose",
+        categoryId: "compute",
+        inputs: { Length: "base.float" },
+        outputs: { Items: "base.object" },
+        resolveHandles: ({ inputs }) => {
+            const maxLen = 64;
+            const raw = inputs?.Length ?? 0;
+            const n = Math.max(0, Math.min(maxLen, Math.trunc(Number(raw ?? 0))));
+            if (!Number.isFinite(n))
+                return { inputs: {} };
+            const dyn = {};
+            for (let i = 0; i < n; i++)
+                dyn[`Item${i}`] = { typeId: "base.object" };
+            return { inputs: dyn };
+        },
+        inputDefaults: { Length: 0 },
+        impl: (ins) => {
+            const length = Math.max(0, Math.trunc(Number(ins.Length ?? 0)));
+            if (!Number.isFinite(length))
+                return { Items: [] };
+            return { Items: Array.from({ length }, (_, i) => ins[`Item${i}`]) };
+        },
+    });
+    // Decompose array into dynamic item outputs
+    registry.registerNode({
+        id: "base.array.decompose",
+        categoryId: "compute",
+        inputs: { Items: "base.object" },
+        outputs: {},
+        resolveHandles: ({ inputs }) => {
+            const maxLen = 64;
+            const arr = Array.isArray(inputs?.Items) ? inputs?.Items : [];
+            const n = Math.max(0, Math.min(maxLen, arr.length));
+            const dyn = {};
+            for (let i = 0; i < n; i++)
+                dyn[`Item${i}`] = "base.object";
+            return { outputs: dyn };
+        },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Items) ? ins.Items : [];
+            const out = {};
+            const n = Math.max(0, Math.min(64, arr.length));
+            for (let i = 0; i < n; i++)
+                out[`Item${i}`] = arr[i];
+            return out;
+        },
+    });
+    // Select
+    registry.registerNode({
+        id: "base.select",
+        categoryId: "compute",
+        inputs: { Cond: "base.bool", Then: "base.object", Else: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => ({
+            Result: ins.Cond ? ins.Then : ins.Else,
+        }),
+    });
+    // Combine XYZ
+    registry.registerNode({
+        id: "base.compareXYZ",
+        categoryId: "compute",
+        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);
+            const len = Math.max(xx.length, z.length);
+            const out = new Array(len)
+                .fill(0)
+                .map((_, i) => [Number(xx[i] ?? 0), Number(y[i] ?? 0), Number(z[i] ?? 0)]);
+            return { XYZ: out };
+        },
+    });
+    // Separate XYZ
+    registry.registerNode({
+        id: "base.separateXYZ",
+        categoryId: "compute",
+        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));
+            const Y = arr.map((v) => Number(v?.[1] ?? 0));
+            const Z = arr.map((v) => Number(v?.[2] ?? 0));
+            return { X, Y, Z };
+        },
+    });
+    // Indices
+    registry.registerNode({
+        id: "base.indices",
+        categoryId: "compute",
+        inputs: { Domain: "base.float" },
+        outputs: { Indices: "base.float[]" },
+        impl: (ins) => {
+            const n = Math.trunc(ins.Domain);
+            return { Indices: Array.from({ length: n }, (_, i) => i) };
+        },
+    });
+    // Random Numbers
+    registry.registerNode({
+        id: "base.randomNumbers",
+        categoryId: "compute",
+        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);
+            const max = Number(ins.Max ?? 1);
+            const rng = lcg(Number(ins.Seed ?? 1));
+            const out = Array.from({ length: len }, () => min + rng() * (max - min));
+            return { Values: out };
+        },
+    });
+    // Random Vectors
+    registry.registerNode({
+        id: "base.randomXYZs",
+        categoryId: "compute",
+        inputs: {
+            Domain: "base.float",
+            Min: "base.vec3",
+            Max: "base.vec3",
+            Seed: "base.float",
+        },
+        outputs: { Values: "base.vec3[]" },
+        // Registry-level defaults for convenience
+        inputDefaults: { Domain: 10, Min: [0, 0, 0], Max: [1, 1, 1], Seed: 1 },
+        impl: (ins) => {
+            const len = Math.trunc(ins.Domain);
+            const min = ins.Min ?? [0, 0, 0];
+            const max = ins.Max ?? [1, 1, 1];
+            const rng = lcg(Number(ins.Seed ?? 1));
+            const out = Array.from({ length: len }, () => [
+                min[0] + rng() * (max[0] - min[0]),
+                min[1] + rng() * (max[1] - min[1]),
+                min[2] + rng() * (max[2] - min[2]),
+            ]);
+            return { Values: out };
+        },
+    });
+    // Timer
+    registry.registerNode({
+        id: "base.timer",
+        categoryId: "compute",
+        inputs: {
+            Enabled: "base.bool",
+            IntervalMs: "base.float",
+            Immediate: "base.bool",
+        },
+        outputs: { Now: "base.float", Count: "base.float" },
+        inputDefaults: { Enabled: true, IntervalMs: 1000, Immediate: true },
+        impl: (ins, ctx) => {
+            const enabled = Boolean(ins.Enabled);
+            const intervalMs = Math.max(1, Math.trunc(Number(ins.IntervalMs ?? 1000)));
+            const immediate = Boolean(ins.Immediate);
+            const stop = () => {
+                const id = ctx.state.timerId;
+                if (id !== undefined) {
+                    clearInterval(id);
+                    ctx.setState({ timerId: undefined });
+                }
+            };
+            if (!enabled) {
+                stop();
+                return;
+            }
+            // restart timer with new settings
+            stop();
+            let count = 0;
+            if (immediate) {
+                ctx.emit("Now", Date.now());
+                ctx.emit("Count", count);
+                count += 1;
+            }
+            const id = setInterval(() => {
+                ctx.emit("Now", Date.now());
+                ctx.emit("Count", count);
+                count += 1;
+            }, intervalMs);
+            ctx.setState({ timerId: id });
+        },
+        lifecycle: {
+            dispose: (ctx) => {
+                const id = ctx.state.timerId;
+                if (id !== undefined) {
+                    clearInterval(id);
+                    ctx.setState({ timerId: undefined });
+                }
+            },
+        },
+    });
+    // ------------------------- JSON/object utilities -------------------------
+    registry.registerNode({
+        id: "base.object.get",
+        categoryId: "compute",
+        inputs: { Object: "base.object", Pointers: "base.string[]" },
+        outputs: { Values: "base.object" },
+        impl: (ins) => {
+            const obj = ins.Object;
+            const pointers = (ins.Pointers || []).map(String);
+            const out = {};
+            for (const p of pointers)
+                out[p] = jsonPointerGet(obj, p);
+            return { Values: out };
+        },
+    });
+    registry.registerNode({
+        id: "base.object.set",
+        categoryId: "compute",
+        inputs: {
+            Object: "base.object",
+            Pointers: "base.string[]",
+            NewValues: "base.object",
+        },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const pointers = (ins.Pointers || []).map(String);
+            const values = (ins.NewValues || []).map(String);
+            let cur = structuredClone(ins.Object);
+            for (let i = 0; i < pointers.length; i++) {
+                const p = pointers[i];
+                const raw = values[i];
+                let val = raw;
+                if (typeof raw === "string") {
+                    try {
+                        val = JSON.parse(raw);
+                    }
+                    catch {
+                        /* keep as string */
+                    }
+                }
+                cur = jsonPointerSet(cur, p, val);
+            }
+            return { Result: cur };
+        },
+    });
+    registry.registerNode({
+        id: "base.object.remove",
+        categoryId: "compute",
+        inputs: { Object: "base.object", Pointers: "base.string[]" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const pointers = (ins.Pointers || []).map(String);
+            let cur = structuredClone(ins.Object);
+            for (const p of pointers)
+                cur = jsonPointerRemove(cur, p);
+            return { Result: cur };
+        },
+    });
+    registry.registerNode({
+        id: "base.object.merge",
+        categoryId: "compute",
+        inputs: { A: "base.object", B: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => ({
+            Result: deepMerge(ins.A, ins.B),
+        }),
+    });
+    registry.registerNode({
+        id: "base.object.keys",
+        categoryId: "compute",
+        inputs: { Object: "base.object" },
+        outputs: { Keys: "base.string[]" },
+        impl: (ins) => {
+            const obj = ins.Object;
+            const keys = isPlainObject(obj) ? Object.keys(obj) : Array.isArray(obj) ? Object.keys(obj) : [];
+            return { Keys: keys };
+        },
+    });
+    registry.registerNode({
+        id: "base.object.values",
+        categoryId: "compute",
+        inputs: { Object: "base.object" },
+        outputs: { Values: "base.object" },
+        impl: (ins) => {
+            const obj = ins.Object;
+            const vals = isPlainObject(obj) ? Object.values(obj) : Array.isArray(obj) ? Object.values(obj) : [];
+            return { Values: vals };
+        },
+    });
+    registry.registerNode({
+        id: "base.object.patch",
+        categoryId: "compute",
+        inputs: { Object: "base.object", Ops: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const root = structuredClone(ins.Object);
+            const opsRaw = ins.Ops;
+            const ops = Array.isArray(opsRaw) ? opsRaw : opsRaw ? [opsRaw] : [];
+            let cur = root;
+            for (const op of ops) {
+                if (!op || typeof op !== "object")
+                    continue;
+                const kind = String(op.op || "");
+                const path = String(op.path || "");
+                if (kind === "add" || kind === "replace") {
+                    cur = jsonPointerSet(cur, path, op.value);
+                }
+                else if (kind === "remove") {
+                    cur = jsonPointerRemove(cur, path);
+                }
+                else if (kind === "test") {
+                    const got = jsonPointerGet(cur, path);
+                    const expected = op.value;
+                    const ok = JSON.stringify(got) === JSON.stringify(expected);
+                    if (!ok)
+                        throw new Error(`objectPatch test failed at ${path}`);
+                }
+            }
+            return { Result: cur };
+        },
+    });
+    registry.registerNode({
+        id: "base.array.concat",
+        categoryId: "compute",
+        inputs: { A: "base.object", B: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const a = Array.isArray(ins.A) ? ins.A : [];
+            const b = Array.isArray(ins.B) ? ins.B : [];
+            return { Result: [...a, ...b] };
+        },
+    });
+    registry.registerNode({
+        id: "base.array.flatten",
+        categoryId: "compute",
+        inputs: { Objects: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Objects) ? ins.Objects : [];
+            const out = [];
+            for (const v of arr) {
+                if (Array.isArray(v))
+                    out.push(...v);
+                else
+                    out.push(v);
+            }
+            return { Result: out };
+        },
+    });
+    registry.registerNode({
+        id: "base.array.sortBy",
+        categoryId: "compute",
+        inputs: { Objects: "base.object", Pointers: "base.string[]" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Objects) ? ins.Objects : [];
+            const pointers = (ins.Pointers || []).map(String);
+            const out = [...arr].sort((a, b) => {
+                for (const p of pointers) {
+                    const av = jsonPointerGet(a, p);
+                    const bv = jsonPointerGet(b, p);
+                    if (av === bv)
+                        continue;
+                    if (av === undefined)
+                        return 1;
+                    if (bv === undefined)
+                        return -1;
+                    if (av < bv)
+                        return -1;
+                    if (av > bv)
+                        return 1;
+                }
+                return 0;
+            });
+            return { Result: out };
+        },
+    });
+    return registry;
+}
+export function registerDelayNode(registry) {
+    registry.registerNode({
+        id: "async.delay",
+        categoryId: "compute",
+        inputs: { Value: "base.float", DelayMs: "base.float" },
+        outputs: { Output: "base.float" },
+        impl: async (ins, ctx) => {
+            const ms = Number(ins.DelayMs ?? 200);
+            const valueRaw = ins.Value;
+            if (valueRaw === undefined || valueRaw === null || Number.isNaN(Number(valueRaw))) {
+                return; // wait until x is present to avoid NaN emissions
+            }
+            await new Promise((resolve, reject) => {
+                const id = setTimeout(resolve, ms);
+                const onAbort = () => {
+                    clearTimeout(id);
+                    reject(new DOMException("Aborted", "AbortError"));
+                };
+                if (ctx.abortSignal.aborted)
+                    return onAbort();
+                ctx.abortSignal.addEventListener("abort", onAbort, { once: true });
+            });
+            return { Output: Number(valueRaw) };
+        },
+    });
+}
+function sleepWithAbort(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const id = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(id);
+            cleanup();
+            reject(new DOMException("Aborted", "AbortError"));
+        };
+        const cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+        };
+        if (signal.aborted)
+            return onAbort();
+        signal.addEventListener("abort", onAbort);
+    });
+}
+export function registerProgressNodes(registry) {
+    registry.registerNode({
+        id: "async.progress",
+        categoryId: "compute",
+        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)));
+            const shouldError = Boolean(ins.ShouldError);
+            for (let i = 0; i < steps; i++) {
+                ctx.reportProgress?.(i / steps);
+                await sleepWithAbort(delayMs, ctx.abortSignal);
+                if (shouldError && i >= Math.floor(steps * 0.7)) {
+                    ctx.reportProgress?.(i / steps);
+                    throw new Error("progressWorker: simulated failure at 70% progress");
+                }
+            }
+            ctx.reportProgress?.(1);
+            return { Done: `Completed ${steps} steps` };
+        },
+    });
+}
+export function createRuntime(registry, def, opts) {
+    const builder = new GraphBuilder(registry);
+    const report = builder.validate(def);
+    if (!report.ok)
+        throw new Error("Validation failed: " + report.issues.map((i) => `${i.code}:${i.message}`).join(", "));
+    return builder.build(def, opts);
+}
+export function generateId(prefix, used = new Set()) {
+    let id;
+    let attempts = 0;
+    do {
+        id = `${prefix}${Math.random().toString(36).slice(2, 8)}`;
+        attempts++;
+        if (attempts > 1000) {
+            id = `${prefix}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 4)}`;
+        }
+    } while (used.has(id));
+    return id;
+}
+//# sourceMappingURL=base.js.map