@skenora/flow 0.1.2

package/dist/core/flow-runtime.js

@@ -0,0 +1,711 @@
+import { EventHub, } from "@skenora/events";
+import { FLOW_MATERIAL_PROPERTIES, } from "../model/types.js";
+import { createBuiltInFlowNodeRegistry, } from "../model/node-registry.js";
+import { FlowValidationError, validateFlowGraph } from "../model/validation.js";
+export class FlowRuntime {
+    host;
+    events;
+    nodeRegistry;
+    #ownsEvents;
+    #maxSteps;
+    #executors = new Map();
+    #graphs = new Map();
+    #subscriptions = new Map();
+    #runs = new Map();
+    #disposed = false;
+    constructor(host, options = {}) {
+        this.host = host;
+        this.events = options.events ?? new EventHub();
+        this.#ownsEvents = options.events === undefined;
+        this.#maxSteps = options.maxSteps ?? 1_000;
+        if (!Number.isInteger(this.#maxSteps) || this.#maxSteps < 1) {
+            throw new Error("FlowRuntime maxSteps must be a positive integer");
+        }
+        this.nodeRegistry = createBuiltInFlowNodeRegistry();
+        for (const [type, executor] of Object.entries(createBuiltInExecutors())) {
+            if (!this.nodeRegistry.has(type)) {
+                throw new Error(`Built-in Flow node definition is missing: ${type}`);
+            }
+            this.#executors.set(type, executor);
+        }
+        for (const registration of options.nodes ?? []) {
+            this.registerNode(registration.definition, registration.executor);
+        }
+    }
+    registerNode(definition, executor) {
+        this.#assertActive();
+        const { type } = definition;
+        const normalizedType = type.toLowerCase();
+        if (["network", "http", "https", "api", "websocket", "remote", "dom"].some((prefix) => normalizedType === prefix ||
+            normalizedType.startsWith(`${prefix}.`) ||
+            normalizedType.startsWith(`${prefix}:`))) {
+            throw new Error(`Side-effect category is not allowed in Skenora Flow: ${type}`);
+        }
+        if (typeof executor !== "function") {
+            throw new Error(`Flow node executor must be a function: ${type}`);
+        }
+        const unregisterDefinition = this.nodeRegistry.register(definition);
+        this.#executors.set(type, executor);
+        return () => {
+            if (this.#executors.get(type) === executor)
+                this.#executors.delete(type);
+            unregisterDefinition();
+        };
+    }
+    mount(graph) {
+        this.#assertActive();
+        const ownedGraph = ownFlowGraph(graph);
+        const validation = validateFlowGraph(ownedGraph, this.nodeRegistry);
+        if (!validation.valid) {
+            throw new FlowValidationError(validation.issues);
+        }
+        this.unmount(ownedGraph.id);
+        this.#graphs.set(ownedGraph.id, ownedGraph);
+        if (!ownedGraph.enabled)
+            return;
+        const controller = new AbortController();
+        this.#subscriptions.set(ownedGraph.id, controller);
+        for (const trigger of ownedGraph.nodes.filter((node) => node.enabled !== false &&
+            this.nodeRegistry.get(node.type)?.category === "trigger")) {
+            if (trigger.type === "trigger.event") {
+                const eventType = stringConfig(trigger, "event");
+                this.host.events.source.subscribe(eventType, (payload, event) => {
+                    if (matchesTrigger(trigger, payload)) {
+                        this.#triggerFromSubscription(ownedGraph.id, trigger.id, payload, event);
+                    }
+                }, { signal: controller.signal });
+            }
+            if (trigger.type === "trigger.pointer") {
+                const pointerEvent = stringConfig(trigger, "event", "pick");
+                this.host.events.source.subscribe(`runtime.pointer.${pointerEvent}`, (payload, event) => {
+                    if (matchesTrigger(trigger, payload)) {
+                        this.#triggerFromSubscription(ownedGraph.id, trigger.id, payload, event);
+                    }
+                }, { signal: controller.signal });
+            }
+            if (trigger.type === "trigger.animation") {
+                const animationEvent = stringConfig(trigger, "event", "completed");
+                this.host.events.source.subscribe(`runtime.animation.${animationEvent}`, (payload, event) => {
+                    if (matchesTrigger(trigger, payload)) {
+                        this.#triggerFromSubscription(ownedGraph.id, trigger.id, payload, event);
+                    }
+                }, { signal: controller.signal });
+            }
+            if (trigger.type === "trigger.variable") {
+                this.host.events.source.subscribe("variable.changed", (payload, event) => {
+                    if (matchesTrigger(trigger, payload)) {
+                        this.#triggerFromSubscription(ownedGraph.id, trigger.id, payload, event);
+                    }
+                }, { signal: controller.signal });
+            }
+            if (trigger.type === "trigger.timer") {
+                this.#mountTimer(ownedGraph, trigger, controller.signal);
+            }
+        }
+    }
+    unmount(graphId) {
+        this.#assertActive();
+        this.#subscriptions.get(graphId)?.abort();
+        this.#subscriptions.delete(graphId);
+        this.#graphs.delete(graphId);
+        for (const [runId, run] of this.#runs) {
+            if (run.graphId !== graphId)
+                continue;
+            run.controller.abort();
+            this.#runs.delete(runId);
+        }
+    }
+    start(graphId, payload) {
+        this.#assertActive();
+        const graph = this.#getGraph(graphId);
+        if (!graph.enabled)
+            return Promise.resolve([]);
+        const triggers = graph.nodes.filter((node) => node.type === "trigger.scene.ready" && node.enabled !== false);
+        return Promise.all(triggers.map((trigger) => this.trigger(graphId, trigger.id, payload)));
+    }
+    async trigger(graphId, triggerNodeId, payload, triggerEvent) {
+        this.#assertActive();
+        const graph = this.#getGraph(graphId);
+        if (!graph.enabled) {
+            throw new Error(`Flow graph is disabled: ${graphId}`);
+        }
+        const trigger = graph.nodes.find((node) => node.id === triggerNodeId);
+        if (!trigger ||
+            trigger.enabled === false ||
+            this.nodeRegistry.get(trigger.type)?.category !== "trigger") {
+            throw new Error(`Flow trigger not found: ${triggerNodeId}`);
+        }
+        const active = [...this.#runs.entries()].filter(([, run]) => run.graphId === graphId);
+        if (graph.concurrency === "drop" && active[0])
+            return active[0][0];
+        if (graph.concurrency === "restart") {
+            for (const [, run] of active)
+                run.controller.abort();
+        }
+        const runId = createRunId();
+        const controller = new AbortController();
+        this.#runs.set(runId, { controller, graphId });
+        const startedEvent = this.events.publish("flow.run.started", { runId, graphId, triggerNodeId }, {
+            source: "flow",
+            ...(triggerEvent
+                ? {
+                    correlationId: triggerEvent.correlationId,
+                    causationId: triggerEvent.id,
+                }
+                : {}),
+        });
+        const context = {
+            runId,
+            graphId,
+            triggerNodeId,
+            payload,
+            correlationId: startedEvent.correlationId,
+            causationId: startedEvent.id,
+            signal: controller.signal,
+        };
+        try {
+            const steps = await this.#executeRun(graph, trigger, context);
+            if (controller.signal.aborted) {
+                if (!this.#disposed) {
+                    this.events.publish("flow.run.cancelled", { runId, graphId }, flowEventMetadata(context));
+                }
+            }
+            else {
+                this.events.publish("flow.run.completed", { runId, graphId, steps }, flowEventMetadata(context));
+            }
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                if (!this.#disposed) {
+                    this.events.publish("flow.run.cancelled", { runId, graphId }, flowEventMetadata(context));
+                }
+                return runId;
+            }
+            this.events.publish("flow.run.failed", { runId, graphId, error }, flowEventMetadata(context));
+            throw error;
+        }
+        finally {
+            this.#runs.delete(runId);
+        }
+        return runId;
+    }
+    cancel(runId) {
+        this.#runs.get(runId)?.controller.abort();
+    }
+    cancelAll(graphId) {
+        this.#assertActive();
+        let cancelled = 0;
+        for (const run of this.#runs.values()) {
+            if (graphId !== undefined && run.graphId !== graphId)
+                continue;
+            if (run.controller.signal.aborted)
+                continue;
+            run.controller.abort();
+            cancelled += 1;
+        }
+        return cancelled;
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        for (const controller of this.#subscriptions.values())
+            controller.abort();
+        for (const run of this.#runs.values())
+            run.controller.abort();
+        this.#subscriptions.clear();
+        this.#runs.clear();
+        this.#graphs.clear();
+        this.#executors.clear();
+        if (this.#ownsEvents)
+            this.events.dispose();
+    }
+    async #executeRun(graph, trigger, context) {
+        let steps = 0;
+        const queue = controlTargets(graph, trigger.id, "next");
+        const valueCache = new Map();
+        valueCache.set(trigger.id, { payload: context.payload });
+        while (queue.length > 0) {
+            if (context.signal.aborted)
+                break;
+            steps += 1;
+            if (steps > this.#maxSteps) {
+                throw new Error(`Flow exceeded ${this.#maxSteps} execution steps`);
+            }
+            const next = queue.shift();
+            if (!next)
+                continue;
+            const node = graph.nodes.find((candidate) => candidate.id === next.targetNodeId);
+            if (!node || node.enabled === false)
+                continue;
+            let result;
+            try {
+                const values = await this.#resolveInputs(graph, node, context, valueCache, new Set());
+                result = await this.#executeNode(node, values, context);
+            }
+            catch (error) {
+                if (context.signal.aborted)
+                    break;
+                this.events.publish("flow.node.failed", { runId: context.runId, graphId: graph.id, nodeId: node.id, error }, flowEventMetadata(context));
+                if (graph.errorPolicy !== "continue")
+                    throw error;
+                continue;
+            }
+            valueCache.set(node.id, result.values ?? {});
+            for (const port of result.control ?? ["next"]) {
+                queue.push(...controlTargets(graph, node.id, port));
+            }
+        }
+        return steps;
+    }
+    async #resolveInputs(graph, node, context, cache, resolving) {
+        const values = {};
+        const edges = graph.edges.filter((edge) => edge.kind === "value" && edge.targetNodeId === node.id);
+        for (const edge of edges) {
+            throwIfFlowAborted(context.signal);
+            if (resolving.has(edge.sourceNodeId)) {
+                throw new Error(`Value dependency cycle at node ${edge.sourceNodeId}`);
+            }
+            let sourceValues = cache.get(edge.sourceNodeId);
+            if (!sourceValues) {
+                const source = graph.nodes.find((candidate) => candidate.id === edge.sourceNodeId);
+                if (!source || source.enabled === false)
+                    continue;
+                resolving.add(source.id);
+                const sourceInputs = await this.#resolveInputs(graph, source, context, cache, resolving);
+                const result = await this.#executeNode(source, sourceInputs, context);
+                sourceValues = result.values ?? {};
+                cache.set(source.id, sourceValues);
+                resolving.delete(source.id);
+            }
+            const definition = this.nodeRegistry.get(node.type);
+            const port = definition?.inputs.find((candidate) => candidate.kind === "value" && candidate.name === edge.targetPort);
+            const nextValue = sourceValues[edge.sourcePort];
+            if (port?.multiple) {
+                const previous = values[edge.targetPort];
+                values[edge.targetPort] = [
+                    ...(Array.isArray(previous) ? previous : []),
+                    nextValue,
+                ];
+            }
+            else {
+                values[edge.targetPort] = nextValue;
+            }
+        }
+        return values;
+    }
+    async #executeNode(node, values, context) {
+        throwIfFlowAborted(context.signal);
+        const executor = this.#executors.get(node.type);
+        if (!executor)
+            throw new Error(`No Flow executor registered for ${node.type}`);
+        this.events.publish("flow.node.started", { runId: context.runId, graphId: context.graphId, nodeId: node.id }, flowEventMetadata(context));
+        const input = {
+            node,
+            values,
+            context,
+            host: this.host,
+        };
+        const result = await executor(input);
+        throwIfFlowAborted(context.signal);
+        this.events.publish("flow.node.completed", { runId: context.runId, graphId: context.graphId, nodeId: node.id }, flowEventMetadata(context));
+        return result;
+    }
+    #mountTimer(graph, node, signal) {
+        const interval = Math.max(numberConfig(node, "intervalMs", 1_000), 16);
+        const repeat = Boolean(node.config.repeat ?? true);
+        const tick = () => {
+            if (signal.aborted)
+                return;
+            this.#triggerFromSubscription(graph.id, node.id, {
+                occurredAt: Date.now(),
+            });
+            if (repeat)
+                timer = globalThis.setTimeout(tick, interval);
+        };
+        let timer = globalThis.setTimeout(tick, interval);
+        signal.addEventListener("abort", () => globalThis.clearTimeout(timer), {
+            once: true,
+        });
+    }
+    #getGraph(graphId) {
+        const graph = this.#graphs.get(graphId);
+        if (!graph)
+            throw new Error(`Flow graph is not mounted: ${graphId}`);
+        return graph;
+    }
+    #triggerFromSubscription(graphId, triggerNodeId, payload, event) {
+        void this.trigger(graphId, triggerNodeId, payload, event).catch(() => {
+            // trigger() already publishes a structured flow.run.failed event.
+        });
+    }
+    #assertActive() {
+        if (this.#disposed)
+            throw new Error("FlowRuntime has been disposed");
+    }
+}
+function createBuiltInExecutors() {
+    return {
+        "value.constant": ({ node }) => ({ values: { value: node.config.value } }),
+        "value.variable": ({ node, host }) => ({
+            values: {
+                value: host.variables.getVariable(stringConfig(node, "name")),
+            },
+        }),
+        "value.entity.state": ({ node, host }) => ({
+            values: {
+                value: host.entities.getEntityState(stringConfig(node, "entityId")),
+            },
+        }),
+        "value.object.get": ({ node, values, context }) => ({
+            values: {
+                value: getValueAtPath(values.object ?? node.config.object ?? context.payload, stringConfig(node, "path")),
+            },
+        }),
+        "value.math": ({ node, values }) => ({
+            values: {
+                value: calculate(values.left ?? node.config.left, values.right ?? node.config.right, stringConfig(node, "operator", "add"), node.id),
+            },
+        }),
+        "value.logic": ({ node, values }) => ({
+            values: {
+                value: logic(values.left ?? node.config.left, values.right ?? node.config.right, stringConfig(node, "operator", "and")),
+            },
+        }),
+        "value.compare": ({ node, values }) => ({
+            values: {
+                value: compare(values.left ?? node.config.left, values.right ?? node.config.right, stringConfig(node, "operator", "equals")),
+            },
+        }),
+        "control.branch": ({ values, node }) => ({
+            control: [
+                Boolean(values.condition ?? node.config.condition) ? "true" : "false",
+            ],
+        }),
+        "control.delay": async ({ values, node, context }) => {
+            await abortableDelay(Number(values.durationMs ?? node.config.durationMs ?? 0), context.signal);
+            return { control: ["next"] };
+        },
+        "action.variable.set": async ({ values, node, host }) => {
+            await host.variables.setVariable(stringConfig(node, "name"), values.value ?? node.config.value);
+            return {};
+        },
+        "action.entity.setEnabled": async ({ values, node, host }) => {
+            await host.entities.setEntityEnabled(stringConfig(node, "entityId"), Boolean(values.enabled ?? node.config.enabled));
+            return {};
+        },
+        "action.entity.setVisible": async ({ values, node, host }) => {
+            await host.entities.setEntityVisible(stringConfig(node, "entityId"), Boolean(values.visible ?? node.config.visible));
+            return {};
+        },
+        "action.entity.setTransform": async ({ values, node, host }) => {
+            await host.entities.setEntityTransform(stringConfig(node, "entityId"), transformUpdate(values.transform ?? node.config.transform, node.id));
+            return {};
+        },
+        "action.entity.setTransparent": async ({ values, node, host }) => {
+            const alpha = Number(values.alpha ?? node.config.alpha ?? 0.5);
+            if (!Number.isFinite(alpha)) {
+                throw new Error(`Flow node ${node.id} requires a finite alpha`);
+            }
+            await host.entities.setEntityTransparent(stringConfig(node, "entityId"), Math.max(0, Math.min(1, alpha)));
+            return {};
+        },
+        "action.entity.clearTransparent": async ({ node, host }) => {
+            await host.entities.setEntityTransparent(stringConfig(node, "entityId"), null);
+            return {};
+        },
+        "action.entity.setOutline": async ({ values, node, host }) => {
+            const color = values.color ?? node.config.color ?? "#3399ff";
+            if (typeof color !== "string") {
+                throw new Error(`Flow node ${node.id} requires a color string`);
+            }
+            await host.entities.setEntityOutline(stringConfig(node, "entityId"), color);
+            return {};
+        },
+        "action.entity.clearOutline": async ({ node, host }) => {
+            await host.entities.setEntityOutline(stringConfig(node, "entityId"), null);
+            return {};
+        },
+        "action.material.set": async ({ values, node, host }) => {
+            await host.materials.setMaterialProperty(stringConfig(node, "materialId"), materialProperty(node), values.value ?? node.config.value);
+            return {};
+        },
+        "action.materialAnimation.play": async ({ node, host, context }) => {
+            if (!host.materialAnimations)
+                throw new Error("Material animation capability is unavailable");
+            await host.materialAnimations.playMaterialAnimation(stringConfig(node, "materialId"), stringConfig(node, "animationId"), { signal: context.signal });
+            return {};
+        },
+        "action.materialAnimation.pause": async ({ node, host }) => {
+            if (!host.materialAnimations)
+                throw new Error("Material animation capability is unavailable");
+            await host.materialAnimations.pauseMaterialAnimation(stringConfig(node, "materialId"), stringConfig(node, "animationId"));
+            return {};
+        },
+        "action.materialAnimation.resume": async ({ node, host }) => {
+            if (!host.materialAnimations)
+                throw new Error("Material animation capability is unavailable");
+            await host.materialAnimations.resumeMaterialAnimation(stringConfig(node, "materialId"), stringConfig(node, "animationId"));
+            return {};
+        },
+        "action.materialAnimation.stop": async ({ node, host }) => {
+            if (!host.materialAnimations)
+                throw new Error("Material animation capability is unavailable");
+            await host.materialAnimations.stopMaterialAnimation(stringConfig(node, "materialId"), stringConfig(node, "animationId"));
+            return {};
+        },
+        "action.materialAnimation.reset": async ({ node, host }) => {
+            if (!host.materialAnimations)
+                throw new Error("Material animation capability is unavailable");
+            await host.materialAnimations.resetMaterialAnimation(stringConfig(node, "materialId"), stringConfig(node, "animationId"));
+            return {};
+        },
+        "action.camera.frame": async ({ values, node, host }) => {
+            const id = values.entityId ?? node.config.entityId;
+            await host.camera.frameEntity(typeof id === "string" ? id : null);
+            return {};
+        },
+        "action.camera.activateEntity": async ({ values, node, host }) => {
+            const entityId = values.entityId ?? node.config.entityId;
+            if (typeof entityId !== "string") {
+                throw new Error(`Flow node ${node.id} requires a camera entityId`);
+            }
+            await host.camera.activateCameraEntity(entityId, Boolean(values.controls ?? node.config.controls ?? false));
+            return {};
+        },
+        "action.camera.restoreViewport": async ({ host }) => {
+            await host.camera.restoreViewportCamera();
+            return {};
+        },
+        "action.camera.playPath": async ({ values, node, host }) => {
+            const pathId = values.pathId ?? node.config.pathId;
+            if (typeof pathId !== "string") {
+                throw new Error(`Flow node ${node.id} requires a camera pathId`);
+            }
+            await host.camera.playCameraPath(pathId);
+            return {};
+        },
+        "action.camera.pausePath": async ({ host }) => {
+            await host.camera.pauseCameraPath();
+            return {};
+        },
+        "action.camera.resumePath": async ({ host }) => {
+            await host.camera.resumeCameraPath();
+            return {};
+        },
+        "action.camera.stopPath": async ({ host }) => {
+            await host.camera.stopCameraPath();
+            return {};
+        },
+        "action.animation.play": async ({ values, node, host }) => {
+            const animation = values.animation ?? node.config.animation;
+            await host.animations.playAnimation(stringConfig(node, "entityId"), typeof animation === "string" ? animation : null);
+            return {};
+        },
+        "action.animation.stop": async ({ values, node, host }) => {
+            const animation = values.animation ?? node.config.animation;
+            await host.animations.stopAnimation(stringConfig(node, "entityId"), typeof animation === "string" ? animation : null);
+            return {};
+        },
+        "action.particle.start": async ({ node, host }) => {
+            await host.particles.setParticleRunning(stringConfig(node, "entityId"), true);
+            return {};
+        },
+        "action.particle.stop": async ({ node, host }) => {
+            await host.particles.setParticleRunning(stringConfig(node, "entityId"), false);
+            return {};
+        },
+        "action.textureAnimation.play": async ({ node, host, context }) => {
+            await host.textureAnimations.playTextureAnimation(stringConfig(node, "animationId"), { signal: context.signal });
+            return {};
+        },
+        "action.textureAnimation.stop": async ({ node, host }) => {
+            await host.textureAnimations.stopTextureAnimation(stringConfig(node, "animationId"));
+            return {};
+        },
+        "action.event.emit": async ({ values, node, host, context }) => {
+            await host.events.emit(stringConfig(node, "event"), values.payload ?? node.config.payload, flowEventMetadata(context));
+            return {};
+        },
+    };
+}
+function controlTargets(graph, sourceNodeId, sourcePort) {
+    return graph.edges.filter((edge) => edge.kind === "control" &&
+        edge.sourceNodeId === sourceNodeId &&
+        edge.sourcePort === sourcePort);
+}
+function stringConfig(node, key, fallback) {
+    const value = node.config[key] ?? fallback;
+    if (typeof value !== "string" || !value) {
+        throw new Error(`Flow node ${node.id} requires string config: ${key}`);
+    }
+    return value;
+}
+function numberConfig(node, key, fallback) {
+    const value = node.config[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function materialProperty(node) {
+    const property = stringConfig(node, "property");
+    if (!FLOW_MATERIAL_PROPERTIES.includes(property)) {
+        throw new Error(`Flow node ${node.id} has unsupported material property`);
+    }
+    return property;
+}
+function flowEventMetadata(context) {
+    return {
+        source: "flow",
+        correlationId: context.correlationId,
+        ...(context.causationId ? { causationId: context.causationId } : {}),
+    };
+}
+function transformUpdate(value, nodeId) {
+    if (!isRecord(value)) {
+        throw new Error(`Flow node ${nodeId} requires a transform object`);
+    }
+    for (const key of ["position", "rotation", "scaling"]) {
+        const component = value[key];
+        if (component !== undefined &&
+            !isNumericRecord(component, ["x", "y", "z"])) {
+            throw new Error(`Flow node ${nodeId} has an invalid transform.${key}`);
+        }
+    }
+    const quaternion = value.rotationQuaternion;
+    if (quaternion !== undefined &&
+        quaternion !== null &&
+        !isNumericRecord(quaternion, ["x", "y", "z", "w"])) {
+        throw new Error(`Flow node ${nodeId} has an invalid transform.rotationQuaternion`);
+    }
+    return value;
+}
+function isNumericRecord(value, keys) {
+    if (!isRecord(value))
+        return false;
+    return keys.every((key) => value[key] === undefined ||
+        (typeof value[key] === "number" && Number.isFinite(value[key])));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function compare(left, right, operator) {
+    if (operator === "equals")
+        return Object.is(left, right);
+    if (operator === "notEquals")
+        return !Object.is(left, right);
+    if (operator === "contains")
+        return String(left).includes(String(right));
+    if (operator === "greater")
+        return Number(left) > Number(right);
+    if (operator === "greaterOrEqual")
+        return Number(left) >= Number(right);
+    if (operator === "less")
+        return Number(left) < Number(right);
+    if (operator === "lessOrEqual")
+        return Number(left) <= Number(right);
+    if (operator === "isEmpty")
+        return left === null || left === undefined || left === "";
+    throw new Error(`Unsupported comparison operator: ${operator}`);
+}
+function calculate(left, right, operator, nodeId) {
+    const a = Number(left);
+    const b = Number(right);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        throw new Error(`Flow node ${nodeId} requires finite numeric inputs`);
+    }
+    if (operator === "add")
+        return a + b;
+    if (operator === "subtract")
+        return a - b;
+    if (operator === "multiply")
+        return a * b;
+    if (operator === "divide") {
+        if (b === 0)
+            throw new Error(`Flow node ${nodeId} cannot divide by zero`);
+        return a / b;
+    }
+    if (operator === "min")
+        return Math.min(a, b);
+    if (operator === "max")
+        return Math.max(a, b);
+    if (operator === "modulo") {
+        if (b === 0)
+            throw new Error(`Flow node ${nodeId} cannot modulo by zero`);
+        return a % b;
+    }
+    throw new Error(`Unsupported math operator: ${operator}`);
+}
+function logic(left, right, operator) {
+    if (operator === "not")
+        return !Boolean(left);
+    if (operator === "and")
+        return Boolean(left) && Boolean(right);
+    if (operator === "or")
+        return Boolean(left) || Boolean(right);
+    if (operator === "xor")
+        return Boolean(left) !== Boolean(right);
+    throw new Error(`Unsupported logic operator: ${operator}`);
+}
+function getValueAtPath(value, path) {
+    const segments = path.split(".").filter(Boolean);
+    let current = value;
+    for (const segment of segments) {
+        if (["__proto__", "prototype", "constructor"].includes(segment)) {
+            throw new Error(`Unsafe object path segment: ${segment}`);
+        }
+        if (!isRecord(current) && !Array.isArray(current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function matchesTrigger(node, payload) {
+    if (!payload || typeof payload !== "object")
+        return true;
+    const record = payload;
+    const entityId = node.config.entityId;
+    if (typeof entityId === "string" && record.entityId !== entityId)
+        return false;
+    const animation = node.config.animation;
+    if (typeof animation === "string" && record.animation !== animation)
+        return false;
+    const name = node.config.name;
+    if (typeof name === "string" && record.name !== name)
+        return false;
+    return true;
+}
+function abortableDelay(durationMs, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = globalThis.setTimeout(resolve, Math.max(durationMs, 0));
+        signal.addEventListener("abort", () => {
+            globalThis.clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+function throwIfFlowAborted(signal) {
+    if (!signal.aborted)
+        return;
+    const error = new Error("Flow execution was aborted");
+    error.name = "AbortError";
+    throw error;
+}
+let runSequence = 0;
+function createRunId() {
+    runSequence += 1;
+    return `flow-run-${Date.now()}-${runSequence}`;
+}
+function ownFlowGraph(graph) {
+    return freezeGraph(structuredClone(graph));
+}
+function freezeGraph(value) {
+    if (value === null || typeof value !== "object" || Object.isFrozen(value)) {
+        return value;
+    }
+    for (const child of Object.values(value))
+        freezeGraph(child);
+    Object.freeze(value);
+    return value;
+}
+//# sourceMappingURL=flow-runtime.js.map