@bian-womp/spark-graph 0.3.90 → 0.3.92

package/lib/src/misc/base.js

@@ -1,1091 +0,0 @@
-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