@hology/core 0.0.212 → 0.0.213

package/dist/gameplay/event-graph/graph.js

@@ -0,0 +1,4 @@
+export class DataOutput{constructor(t,e){this.node=t,this.name=e}}export class Node{constructor(){this.dataOutputs=new Map}output(t="value"){let e=this.dataOutputs.get(t);return null==e&&(e=new DataOutput(this,t),this.dataOutputs.set(t,e)),e}}export class PureNode extends Node{}export class ExecutionNode extends Node{constructor(){super(...arguments),this.executionOutputs=new Map}connect(t,e){if(this.executionOutputs.has(t))throw new Error(`Execution output ${JSON.stringify(t)} is already connected`);return this.executionOutputs.set(t,e),e}then(t){return this.connect("then",t)}getExecutionOutputs(){return this.executionOutputs}}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/event-graph/index.d.ts

@@ -0,0 +1,13 @@
+export * from './compiler.js';
+export * from './asset-references.js';
+export * from './decorators.js';
+export * from './document-compiler.js';
+export * from './graph.js';
+export * from './model.js';
+export * from './nodes/index.js';
+export * from './registry.js';
+export * from './runtime.js';
+export * from './runtime-assets.js';
+export * from './type-inference.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gameplay/event-graph/index.js

@@ -0,0 +1,4 @@
+export*from"./compiler.js";export*from"./asset-references.js";export*from"./decorators.js";export*from"./document-compiler.js";export*from"./graph.js";export*from"./model.js";export*from"./nodes/index.js";export*from"./registry.js";export*from"./runtime.js";export*from"./runtime-assets.js";export*from"./type-inference.js";export*from"./types.js";/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/event-graph/model.d.ts

@@ -0,0 +1,71 @@
+import type { EventGraphType } from './types.js';
+export type EventGraphNodeKind = 'event.beginPlay' | 'event.update' | 'event.endPlay' | 'event.observable' | 'event.source' | 'event.bindSource' | 'flow.branch' | 'flow.sequence' | 'flow.parallel' | 'flow.switch' | 'flow.delay' | 'flow.interval' | 'flow.clearInterval' | 'flow.forLoop' | 'flow.isValid' | 'flow.forEach' | 'flow.doOnce' | 'flow.gate' | 'debug.log' | 'constant.boolean' | 'constant.number' | 'constant.string' | 'constant.vector2' | 'constant.vector3' | 'math.add' | 'math.subtract' | 'math.multiply' | 'math.divide' | 'math.modulo' | 'vector.length' | 'vector.lengthSquared' | 'vector.distance' | 'vector.distanceSquared' | 'vector.normalize' | 'vector.dot' | 'vector.cross' | 'vector.lerp' | 'vector.applyRotation' | 'compare.equal' | 'compare.notEqual' | 'compare.greaterThan' | 'compare.greaterThanOrEqual' | 'compare.lessThan' | 'compare.lessThanOrEqual' | 'boolean.and' | 'boolean.or' | 'boolean.not' | 'variable.get' | 'variable.set' | 'actor.reference' | 'actor.component' | 'actor.getProperty' | 'actor.setProperty' | 'actor.tweenProperty' | 'transform.moveTo' | 'transform.moveBy' | 'transform.rotateTo' | 'transform.rotateBy' | 'transform.scaleTo' | 'transform.scaleBy' | 'actor.callMethod' | 'actor.tryCallMethod' | 'actor.findByType' | 'actor.findAllByType' | 'actor.spawnClass' | 'actor.spawnPrefab' | 'actor.destroy' | 'asset.reference' | 'vfx.play' | 'sequence.play' | 'prefab.destroy';
+export type EventGraphAssetKind = 'prefab' | 'vfx' | 'sequence';
+export type EventGraphTransformSpace = 'local' | 'world';
+export type EventGraphTransformAxis = 'x' | 'y' | 'z';
+/** Persisted soft reference. Runtime graph values lower this to the stable asset id. */
+export interface EventGraphAssetReference {
+    [key: string]: string;
+    assetId: string;
+    assetType: EventGraphAssetKind;
+}
+export type EventGraphSerializableValue = null | boolean | number | string | EventGraphSerializableValue[] | {
+    [key: string]: EventGraphSerializableValue;
+};
+export type EventGraphVector2Literal = [number, number];
+export type EventGraphVector3Literal = [number, number, number];
+export type EventGraphEulerLiteral = [number, number, number];
+export interface EventGraphSocketRef {
+    nodeId: string;
+    port: string;
+}
+export interface EventGraphInputLiteral {
+    value: EventGraphSerializableValue;
+}
+export type EventGraphInput = EventGraphSocketRef | EventGraphInputLiteral;
+export interface EventGraphNode {
+    id: string;
+    kind: EventGraphNodeKind;
+    params?: Record<string, EventGraphSerializableValue>;
+    inputs?: Record<string, EventGraphInput>;
+}
+export interface EventGraphEdge {
+    id?: string;
+    from: EventGraphSocketRef;
+    to: EventGraphSocketRef;
+}
+export interface EventGraphGroup {
+    id: string;
+    title: string;
+    nodeIds: string[];
+}
+export interface EventGraphLayout {
+    nodes?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+    groups?: EventGraphGroup[];
+}
+export interface EventGraphVariable {
+    name: string;
+    type?: EventGraphType;
+    defaultValue?: EventGraphSerializableValue;
+}
+/** Persisted event graph data. Editor-only selection and viewport state do not belong here. */
+export interface EventGraphDocument {
+    version: 1;
+    variables?: EventGraphVariable[];
+    nodes: EventGraphNode[];
+    edges: EventGraphEdge[];
+    layout?: EventGraphLayout;
+}
+export declare function createDefaultEventGraphDocument(): EventGraphDocument;
+/**
+ * Returns true only when an authored event entry point can start an execution
+ * chain. Layout-only/default event nodes should not make prefab spawning pay
+ * for graph compilation or subscriptions.
+ */
+export declare function hasExecutableEventGraphDocument(document: EventGraphDocument | null | undefined): document is EventGraphDocument;
+/** Normalizes additive version-1 aliases without cloning current documents. */
+export declare function normalizeEventGraphDocument(document: EventGraphDocument): EventGraphDocument;
+//# sourceMappingURL=model.d.ts.map

package/dist/gameplay/event-graph/model.js

@@ -0,0 +1,4 @@
+export function createDefaultEventGraphDocument(){return{version:1,variables:[],nodes:[{id:"begin-play",kind:"event.beginPlay"},{id:"update",kind:"event.update"},{id:"end-play",kind:"event.endPlay"}],edges:[],layout:{nodes:{"begin-play":{x:0,y:0},update:{x:0,y:220},"end-play":{x:0,y:440}}}}}export function hasExecutableEventGraphDocument(e){if(null==e)return!1;const n=new Set(e.nodes.filter(e=>"event.bindSource"!==e.kind&&e.kind.startsWith("event.")).map(e=>e.id));return e.edges.some(e=>n.has(e.from.nodeId)&&"then"===e.from.port)}export function normalizeEventGraphDocument(e){var n;const o=new Set(e.nodes.filter(e=>"actor.spawnPrefab"===e.kind||"vfx.play"===e.kind).map(e=>e.id)),t=new Set(e.nodes.filter(e=>"flow.doOnce"===e.kind).map(e=>e.id)),d=e.nodes.some(e=>o.has(e.id)&&null!=e.inputs?.location)||e.edges.some(e=>o.has(e.to.nodeId)&&"location"===e.to.port),i=e.edges.some(e=>t.has(e.from.nodeId)&&"completed"===e.from.port);if(!d&&!i)return e;const r=structuredClone(e);for(const e of r.nodes)o.has(e.id)&&null!=e.inputs?.location&&((n=e.inputs).position??(n.position=e.inputs.location),delete e.inputs.location);for(const e of r.edges)o.has(e.to.nodeId)&&"location"===e.to.port&&(e.to.port="position"),t.has(e.from.nodeId)&&"completed"===e.from.port&&(e.from.port="then");return r}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/event-graph/nodes/execution-nodes.d.ts

@@ -0,0 +1,115 @@
+import type { CompilationContext } from '../compiler.js';
+import { ExecutionNode, type ExecutionCompileResult, type ValueInput } from '../graph.js';
+export declare class StartNode extends ExecutionNode {
+    compileExecution(): ExecutionCompileResult;
+}
+export declare class LogNode extends ExecutionNode {
+    readonly value: ValueInput;
+    constructor(value: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class CallScopeNode extends ExecutionNode {
+    compileExecution(): ExecutionCompileResult;
+}
+export declare class DelayNode extends ExecutionNode {
+    readonly delayMs: ValueInput;
+    constructor(delayMs: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class IntervalNode extends ExecutionNode {
+    private readonly nodeId;
+    private readonly intervalMs;
+    readonly timerId: import("../graph.js").DataOutput<number>;
+    constructor(nodeId: string, intervalMs: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class ClearIntervalNode extends ExecutionNode {
+    private readonly timerId;
+    constructor(timerId: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class SequenceNode extends ExecutionNode {
+    private readonly ports;
+    constructor(ports: readonly string[]);
+    compileExecution(): ExecutionCompileResult;
+}
+export declare class ForLoopNode extends ExecutionNode {
+    private readonly firstIndex;
+    private readonly lastIndex;
+    readonly index: import("../graph.js").DataOutput<number>;
+    constructor(firstIndex: ValueInput, lastIndex: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class DoOnceNode extends ExecutionNode {
+    private readonly nodeId;
+    private readonly entryPort;
+    private readonly startClosed;
+    constructor(nodeId: string, entryPort: string, startClosed: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class GateNode extends ExecutionNode {
+    private readonly nodeId;
+    private readonly entryPort;
+    private readonly startClosed;
+    constructor(nodeId: string, entryPort: string, startClosed: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class AssignNode extends ExecutionNode {
+    private readonly variable;
+    private readonly value;
+    constructor(variable: string, value: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class AddAssignNode extends ExecutionNode {
+    private readonly variable;
+    private readonly value;
+    constructor(variable: string, value: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+/** Chooses exactly one named execution output without producing a data value. */
+export declare class BranchNode extends ExecutionNode {
+    private readonly condition;
+    constructor(condition: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class IsValidNode extends ExecutionNode {
+    private readonly input;
+    readonly value: import("../graph.js").DataOutput<unknown>;
+    constructor(input: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class ForEachNode extends ExecutionNode {
+    private readonly array;
+    readonly arrayElement: import("../graph.js").DataOutput<unknown>;
+    readonly arrayIndex: import("../graph.js").DataOutput<number>;
+    constructor(array: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+/** Runs named branches concurrently and continues after all complete successfully. */
+export declare class ParallelNode extends ExecutionNode {
+    readonly ports: ReadonlyArray<string>;
+    constructor(...ports: string[]);
+    compileExecution(): ExecutionCompileResult;
+}
+export declare class SelectNode extends ExecutionNode {
+    private readonly expression;
+    private readonly cases;
+    private readonly defaultPort;
+    constructor(expression: ValueInput, cases: ReadonlyArray<{
+        match: string;
+        port: string;
+    }>, defaultPort?: string);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+/**
+ * Demonstrates an impure node with both named execution outputs and named data
+ * outputs. The data pins refer to storage populated when this node executes.
+ */
+export declare class ParseNumberNode extends ExecutionNode {
+    private readonly input;
+    readonly value: import("../graph.js").DataOutput<number>;
+    readonly error: import("../graph.js").DataOutput<string>;
+    constructor(input: ValueInput<string>);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+//# sourceMappingURL=execution-nodes.d.ts.map

package/dist/gameplay/event-graph/nodes/execution-nodes.js

@@ -0,0 +1,4 @@
+import{ExecutionNode as t}from"../graph.js";export class StartNode extends t{compileExecution(){return{}}}export class LogNode extends t{constructor(t){super(),this.value=t}compileExecution(t){return{chunk:`console.log(${t.get(this.value)})`}}}export class CallScopeNode extends t{compileExecution(){return{chunk:"this.foo()",invalidatesValues:!0}}}export class DelayNode extends t{constructor(t){super(),this.delayMs=t}compileExecution(t){return{done:`runtime.delay(${t.get(this.delayMs)})`}}}export class IntervalNode extends t{constructor(t,e){super(),this.nodeId=t,this.intervalMs=e,this.timerId=this.output("timerId")}compileExecution(t){return{route:{kind:"runtimeCallback",callee:"runtime.setInterval",arguments:[JSON.stringify(this.nodeId),t.get(this.intervalMs)],completedPort:"interval",continuationPort:"then",returnValueOutput:t.getOutputVariable(this.timerId)},invalidatesValues:!0}}}export class ClearIntervalNode extends t{constructor(t){super(),this.timerId=t}compileExecution(t){return{chunk:`runtime.clearInterval(${t.get(this.timerId)})`}}}export class SequenceNode extends t{constructor(t){super(),this.ports=t}compileExecution(){return{route:{kind:"sequence",ports:this.ports,continuationPort:"then"}}}}export class ForLoopNode extends t{constructor(t,e){super(),this.firstIndex=t,this.lastIndex=e,this.index=this.output("index")}compileExecution(t){return{route:{kind:"forLoop",firstIndexExpression:t.get(this.firstIndex),lastIndexExpression:t.get(this.lastIndex),indexOutput:t.getOutputVariable(this.index),bodyPort:"loopBody",continuationPort:"completed"}}}}export class DoOnceNode extends t{constructor(t,e,r){super(),this.nodeId=t,this.entryPort=e,this.startClosed=r}compileExecution(t){return{route:{kind:"branch",condition:`runtime.doOnce(${JSON.stringify(this.nodeId)}, ${JSON.stringify(this.entryPort)}, ${t.get(this.startClosed)})`,truePort:"then",falsePort:"__blocked"},invalidatesValues:!0}}}export class GateNode extends t{constructor(t,e,r){super(),this.nodeId=t,this.entryPort=e,this.startClosed=r}compileExecution(t){return{route:{kind:"branch",condition:`runtime.gate(${JSON.stringify(this.nodeId)}, ${JSON.stringify(this.entryPort)}, ${t.get(this.startClosed)})`,truePort:"exit",falsePort:"__blocked"},invalidatesValues:!0}}}export class AssignNode extends t{constructor(t,e){super(),this.variable=t,this.value=e}compileExecution(t){return{chunk:`${t.getVariableName(this.variable)} = ${t.get(this.value)}`,invalidatesValues:!0}}}export class AddAssignNode extends t{constructor(t,e){super(),this.variable=t,this.value=e}compileExecution(t){return{chunk:`${t.getVariableName(this.variable)} += ${t.get(this.value)}`,invalidatesValues:!0}}}export class BranchNode extends t{constructor(t){super(),this.condition=t}compileExecution(t){return{route:{kind:"branch",condition:t.get(this.condition),truePort:"true",falsePort:"false",continuationPort:"then"}}}}export class IsValidNode extends t{constructor(t){super(),this.input=t,this.value=this.output("value")}compileExecution(t){const e=t.getOutputVariable(this.value);return{chunk:`${e} = ${t.get(this.input)}`,route:{kind:"branch",condition:`${e} !== null && ${e} !== undefined`,truePort:"valid",falsePort:"invalid",continuationPort:"then"}}}}export class ForEachNode extends t{constructor(t){super(),this.array=t,this.arrayElement=this.output("arrayElement"),this.arrayIndex=this.output("arrayIndex")}compileExecution(t){return{route:{kind:"forEach",arrayExpression:t.get(this.array),elementOutput:t.getOutputVariable(this.arrayElement),indexOutput:t.getOutputVariable(this.arrayIndex),bodyPort:"loopBody",continuationPort:"completed"}}}}export class ParallelNode extends t{constructor(...t){if(super(),0===t.length)throw new Error("ParallelNode needs at least one branch");if(t.includes("then"))throw new Error('ParallelNode reserves the "then" port for its continuation');if(new Set(t).size!==t.length)throw new Error("ParallelNode branch names must be unique");this.ports=t}compileExecution(){return{route:{kind:"parallel",ports:this.ports,continuationPort:"then"}}}}export class SelectNode extends t{constructor(t,e,r="default"){super(),this.expression=t,this.cases=e,this.defaultPort=r}compileExecution(t){return{route:{kind:"select",expression:t.get(this.expression),cases:this.cases,defaultPort:this.defaultPort,continuationPort:"then"}}}}export class ParseNumberNode extends t{constructor(t){super(),this.input=t,this.value=this.output("value"),this.error=this.output("error")}compileExecution(t){const e=t.getOutputVariable(this.value),r=t.getOutputVariable(this.error),o=`parsed_${t.variable()}`,s=`caught_${t.variable()}`;return{route:{kind:"try",attempt:`const ${o} = Number(${t.get(this.input)})\nif (Number.isNaN(${o})) {\n  throw new Error('The input is not a number')\n}\n${e} = ${o}\n${r} = undefined`,catchVariable:s,recover:`${e} = undefined\n${r} = ${s} instanceof Error ? ${s}.message : String(${s})`,successPort:"success",errorPort:"error"}}}}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/event-graph/nodes/gameplay-nodes.d.ts

@@ -0,0 +1,208 @@
+import type { CompilationContext } from '../compiler.js';
+import type { EventGraphSerializableValue } from '../model.js';
+import type { EventGraphType } from '../types.js';
+import { ExecutionNode, PureNode, type DataCompileResult, type ExecutionCompileResult, type ValueInput, type ValueLiteral } from '../graph.js';
+export type BinaryOperator = '+' | '-' | '*' | '/' | '%' | '===' | '!==' | '>' | '>=' | '<' | '<=' | '&&' | '||';
+export type VectorMathOperator = 'add' | 'subtract' | 'multiply' | 'divide' | 'modulo';
+export type VectorUnaryOperator = 'length' | 'lengthSquared' | 'normalize';
+export type VectorBinaryOperator = 'distance' | 'distanceSquared' | 'dot' | 'cross';
+export declare class LiteralNode extends PureNode {
+    private readonly value;
+    constructor(value: ValueLiteral);
+    compileData(): DataCompileResult;
+}
+export declare class RuntimeLiteralNode extends PureNode {
+    private readonly value;
+    private readonly type;
+    constructor(value: EventGraphSerializableValue, type: EventGraphType);
+    compileData(): DataCompileResult;
+}
+export declare class BinaryOperatorNode extends PureNode {
+    private readonly a;
+    private readonly b;
+    private readonly operator;
+    constructor(a: ValueInput, b: ValueInput, operator: BinaryOperator);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class VectorMathOperatorNode extends PureNode {
+    private readonly a;
+    private readonly b;
+    private readonly operator;
+    constructor(a: ValueInput, b: ValueInput, operator: VectorMathOperator);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class VectorUnaryOperatorNode extends PureNode {
+    private readonly value;
+    private readonly operator;
+    constructor(value: ValueInput, operator: VectorUnaryOperator);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class VectorBinaryOperatorNode extends PureNode {
+    private readonly a;
+    private readonly b;
+    private readonly operator;
+    constructor(a: ValueInput, b: ValueInput, operator: VectorBinaryOperator);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class VectorLerpNode extends PureNode {
+    private readonly a;
+    private readonly b;
+    private readonly alpha;
+    constructor(a: ValueInput, b: ValueInput, alpha: ValueInput);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class VectorApplyRotationNode extends PureNode {
+    private readonly value;
+    private readonly rotation;
+    constructor(value: ValueInput, rotation: ValueInput);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class VectorEqualityNode extends PureNode {
+    private readonly a;
+    private readonly b;
+    private readonly negate;
+    constructor(a: ValueInput, b: ValueInput, negate: boolean);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class NotNode extends PureNode {
+    private readonly value;
+    constructor(value: ValueInput);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+/** Value passed to the currently executing event handler. */
+export declare class EventValueNode extends PureNode {
+    compileData(): DataCompileResult;
+}
+export declare class ActorReferenceNode extends PureNode {
+    private readonly actorId;
+    constructor(actorId: string);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class FindActorByTypeNode extends PureNode {
+    private readonly actorClass;
+    constructor(actorClass: ValueInput);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class FindActorsByTypeNode extends PureNode {
+    private readonly actorClass;
+    constructor(actorClass: ValueInput);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class AssetReferenceNode extends PureNode {
+    private readonly assetId;
+    constructor(assetId: string);
+    compileData(): DataCompileResult;
+}
+export declare class ComponentReferenceNode extends PureNode {
+    private readonly target;
+    private readonly property;
+    constructor(target: ValueInput, property: string);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class GetPropertyNode extends PureNode {
+    private readonly target;
+    private readonly property;
+    constructor(target: ValueInput, property: string);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class GraphVariableNode extends PureNode {
+    private readonly variable;
+    constructor(variable: string);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class SetPropertyNode extends ExecutionNode {
+    private readonly target;
+    private readonly property;
+    private readonly value;
+    constructor(target: ValueInput, property: string, value: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class RuntimeCallbackNode extends ExecutionNode {
+    private readonly runtimeMethod;
+    private readonly args;
+    constructor(runtimeMethod: string, args: readonly ValueInput[]);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export type EventSourceArgumentInput = ValueInput | {
+    kind: 'actorClass';
+    classId: string;
+};
+export declare class BindEventSourceNode extends ExecutionNode {
+    private readonly nodeId;
+    private readonly target;
+    private readonly method;
+    private readonly args;
+    private readonly component?;
+    readonly value: import("../graph.js").DataOutput<unknown>;
+    constructor(nodeId: string, target: ValueInput, method: string, args: readonly EventSourceArgumentInput[], component?: string);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class SetGraphVariableNode extends ExecutionNode {
+    private readonly variable;
+    private readonly value;
+    constructor(variable: string, value: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class CallMethodNode extends ExecutionNode {
+    private readonly target;
+    private readonly method;
+    private readonly args;
+    private readonly awaitResult;
+    readonly value: import("../graph.js").DataOutput<unknown>;
+    constructor(target: ValueInput, method: string, args: ValueInput[], awaitResult?: boolean);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class TryCallMethodNode extends ExecutionNode {
+    private readonly target;
+    private readonly method;
+    private readonly args;
+    private readonly awaitResult;
+    readonly value: import("../graph.js").DataOutput<unknown>;
+    readonly error: import("../graph.js").DataOutput<unknown>;
+    constructor(target: ValueInput, method: string, args: ValueInput[], awaitResult?: boolean);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class SpawnActorNode extends ExecutionNode {
+    private readonly classId;
+    readonly value: import("../graph.js").DataOutput<unknown>;
+    constructor(classId: string);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class SpawnPrefabNode extends ExecutionNode {
+    private readonly prefab;
+    private readonly position;
+    private readonly rotation;
+    readonly instance: import("../graph.js").DataOutput<unknown>;
+    readonly mainActor: import("../graph.js").DataOutput<unknown>;
+    constructor(prefab: ValueInput, position: ValueInput, rotation: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class PlayVfxNode extends ExecutionNode {
+    private readonly asset;
+    private readonly position;
+    private readonly rotation;
+    private readonly autoDestroy;
+    readonly value: import("../graph.js").DataOutput<unknown>;
+    constructor(asset: ValueInput, position: ValueInput, rotation: ValueInput, autoDestroy: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class PlaySequenceNode extends ExecutionNode {
+    private readonly asset;
+    private readonly target;
+    private readonly cameraControlEnabled;
+    private readonly autoDestroy;
+    readonly value: import("../graph.js").DataOutput<unknown>;
+    constructor(asset: ValueInput, target: ValueInput, cameraControlEnabled: ValueInput, autoDestroy: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class DestroyPrefabNode extends ExecutionNode {
+    private readonly instance;
+    constructor(instance: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+export declare class DestroyActorNode extends ExecutionNode {
+    private readonly actor;
+    constructor(actor: ValueInput);
+    compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+//# sourceMappingURL=gameplay-nodes.d.ts.map

package/dist/gameplay/event-graph/nodes/gameplay-nodes.js

@@ -0,0 +1,4 @@
+import{ExecutionNode as t,PureNode as e}from"../graph.js";export class LiteralNode extends e{constructor(t){super(),this.value=t}compileData(){return{outputs:{value:s(this.value)}}}}export class RuntimeLiteralNode extends e{constructor(t,e){super(),this.value=t,this.type=e}compileData(){return{outputs:{value:a(this.value,this.type)}}}}export class BinaryOperatorNode extends e{constructor(t,e,r){super(),this.a=t,this.b=e,this.operator=r}compileData(t){return r(t,"binary",`(${t.get(this.a)} ${this.operator} ${t.get(this.b)})`)}}export class VectorMathOperatorNode extends e{constructor(t,e,r){super(),this.a=t,this.b=e,this.operator=r}compileData(t){return r(t,"vectorMath",`runtime.${function(t){switch(t){case"add":return"mathAdd";case"subtract":return"mathSubtract";case"multiply":return"mathMultiply";case"divide":return"mathDivide";case"modulo":return"mathModulo"}}(this.operator)}(${t.get(this.a)}, ${t.get(this.b)})`)}}export class VectorUnaryOperatorNode extends e{constructor(t,e){super(),this.value=t,this.operator=e}compileData(t){return r(t,"vector",`runtime.${function(t){switch(t){case"length":return"vectorLength";case"lengthSquared":return"vectorLengthSquared";case"normalize":return"vectorNormalize"}}(this.operator)}(${t.get(this.value)})`)}}export class VectorBinaryOperatorNode extends e{constructor(t,e,r){super(),this.a=t,this.b=e,this.operator=r}compileData(t){return r(t,"vector",`runtime.${function(t){switch(t){case"distance":return"vectorDistance";case"distanceSquared":return"vectorDistanceSquared";case"dot":return"vectorDot";case"cross":return"vectorCross"}}(this.operator)}(${t.get(this.a)}, ${t.get(this.b)})`)}}export class VectorLerpNode extends e{constructor(t,e,r){super(),this.a=t,this.b=e,this.alpha=r}compileData(t){return r(t,"vector",`runtime.vectorLerp(${t.get(this.a)}, ${t.get(this.b)}, ${t.get(this.alpha)})`)}}export class VectorApplyRotationNode extends e{constructor(t,e){super(),this.value=t,this.rotation=e}compileData(t){return r(t,"vector",`runtime.vectorApplyRotation(${t.get(this.value)}, ${t.get(this.rotation)})`)}}export class VectorEqualityNode extends e{constructor(t,e,r){super(),this.a=t,this.b=e,this.negate=r}compileData(t){const e=`${t.get(this.a)}.equals(${t.get(this.b)})`;return r(t,"vectorEquals",this.negate?`!(${e})`:e)}}export class NotNode extends e{constructor(t){super(),this.value=t}compileData(t){return r(t,"not",`(!${t.get(this.value)})`)}}export class EventValueNode extends e{compileData(){return{outputs:{value:"eventValue"}}}}export class ActorReferenceNode extends e{constructor(t){super(),this.actorId=t}compileData(t){return r(t,"actor",`runtime.actor(${s(this.actorId)})`)}}export class FindActorByTypeNode extends e{constructor(t){super(),this.actorClass=t}compileData(t){return r(t,"foundActor",`runtime.findActorByType(${t.get(this.actorClass)})`)}}export class FindActorsByTypeNode extends e{constructor(t){super(),this.actorClass=t}compileData(t){return r(t,"foundActors",`runtime.findActorsByType(${t.get(this.actorClass)})`)}}export class AssetReferenceNode extends e{constructor(t){super(),this.assetId=t}compileData(){return{outputs:{value:s(this.assetId)}}}}export class ComponentReferenceNode extends e{constructor(t,e){super(),this.target=t,this.property=e}compileData(t){return r(t,"component",`runtime.component(${t.get(this.target)}, ${s(this.property)})`)}}export class GetPropertyNode extends e{constructor(t,e){super(),this.target=t,this.property=e}compileData(t){return r(t,"property",`runtime.readValue(runtime.getProperty(${t.get(this.target)}, ${s(this.property)}))`)}}export class GraphVariableNode extends e{constructor(t){super(),this.variable=t}compileData(t){return r(t,"variable",`runtime.readValue(runtime.getVariable(${s(this.variable)}))`)}}export class SetPropertyNode extends t{constructor(t,e,r){super(),this.target=t,this.property=e,this.value=r}compileExecution(t){return{chunk:`runtime.setProperty(${t.get(this.target)}, ${s(this.property)}, ${t.get(this.value)})`,invalidatesValues:!0}}}export class RuntimeCallbackNode extends t{constructor(t,e){super(),this.runtimeMethod=t,this.args=e}compileExecution(t){return{route:{kind:"runtimeCallback",callee:`runtime.${this.runtimeMethod}`,arguments:this.args.map(e=>t.get(e)),completedPort:"completed",continuationPort:"then"},invalidatesValues:!0}}}export class BindEventSourceNode extends t{constructor(t,e,r,s,a){super(),this.nodeId=t,this.target=e,this.method=r,this.args=s,this.component=a,this.value=this.output("value")}compileExecution(r){const a=null==this.component?r.get(this.target):`runtime.component(${r.get(this.target)}, ${s(this.component)})`;return{route:{kind:"runtimeCallback",callee:"runtime.bindEventSource",arguments:[s(this.nodeId),a,s(this.method),`[${this.args.map(a=>function(r,a){return"object"!=typeof a||null==a||Array.isArray(a)||a instanceof e||a instanceof t||!("kind"in a)||"actorClass"!==a.kind?r.get(a):`runtime.actorClass(${s(a.classId)})`}(r,a)).join(", ")}]`],completedPort:"triggered",continuationPort:"then",callbackValueOutput:r.getOutputVariable(this.value)},invalidatesValues:!0}}}export class SetGraphVariableNode extends t{constructor(t,e){super(),this.variable=t,this.value=e}compileExecution(t){return{chunk:`runtime.setVariable(${s(this.variable)}, ${t.get(this.value)})`,invalidatesValues:!0}}}export class CallMethodNode extends t{constructor(t,e,r,s=!1){super(),this.target=t,this.method=e,this.args=r,this.awaitResult=s,this.value=this.output("value")}compileExecution(t){const e=`runtime.callMethod(${t.get(this.target)}, ${s(this.method)}, [${this.args.map(e=>t.get(e)).join(", ")}])`;return{chunk:`${t.getOutputVariable(this.value)} = ${this.awaitResult?"await ":""}${e}`,invalidatesValues:!0,requiresAsync:this.awaitResult}}}export class TryCallMethodNode extends t{constructor(t,e,r,s=!1){super(),this.target=t,this.method=e,this.args=r,this.awaitResult=s,this.value=this.output("value"),this.error=this.output("errorValue")}compileExecution(t){const e=t.getOutputVariable(this.value),r=t.getOutputVariable(this.error),a=`caught_${t.variable()}`,o=`runtime.callMethod(${t.get(this.target)}, ${s(this.method)}, [${this.args.map(e=>t.get(e)).join(", ")}])`;return{route:{kind:"try",attempt:`${e} = ${this.awaitResult?"await ":""}${o}\n${r} = undefined`,catchVariable:a,recover:`${e} = undefined\n${r} = ${a}`,successPort:"success",errorPort:"error",continuationPort:"then"},invalidatesValues:!0,requiresAsync:this.awaitResult}}}export class SpawnActorNode extends t{constructor(t){super(),this.classId=t,this.value=this.output("value")}compileExecution(t){return{chunk:`${t.getOutputVariable(this.value)} = await runtime.spawnActor(${s(this.classId)})`,invalidatesValues:!0,requiresAsync:!0}}}export class SpawnPrefabNode extends t{constructor(t,e,r){super(),this.prefab=t,this.position=e,this.rotation=r,this.instance=this.output("instance"),this.mainActor=this.output("mainActor")}compileExecution(t){const e=`spawnedPrefab_${t.variable()}`;return{chunk:`const ${e} = await runtime.spawnPrefab(${t.get(this.prefab)}, ${t.get(this.position)}, ${t.get(this.rotation)})\n${t.getOutputVariable(this.instance)} = ${e}.instance\n${t.getOutputVariable(this.mainActor)} = ${e}.mainActor`,invalidatesValues:!0,requiresAsync:!0}}}export class PlayVfxNode extends t{constructor(t,e,r,s){super(),this.asset=t,this.position=e,this.rotation=r,this.autoDestroy=s,this.value=this.output("value")}compileExecution(t){const e=t.getOutputVariable(this.value);return{chunk:`${e} = await runtime.playVfx(${t.get(this.asset)}, ${t.get(this.position)}, ${t.get(this.rotation)}, ${t.get(this.autoDestroy)})`,invalidatesValues:!0,requiresAsync:!0,route:{kind:"completion",actorExpression:e,completedPort:"completed",continuationPort:"then"}}}}export class PlaySequenceNode extends t{constructor(t,e,r,s){super(),this.asset=t,this.target=e,this.cameraControlEnabled=r,this.autoDestroy=s,this.value=this.output("value")}compileExecution(t){const e=t.getOutputVariable(this.value);return{chunk:`${e} = await runtime.playSequence(${t.get(this.asset)}, ${t.get(this.target)}, ${t.get(this.cameraControlEnabled)}, ${t.get(this.autoDestroy)})`,invalidatesValues:!0,requiresAsync:!0,route:{kind:"completion",actorExpression:e,completedPort:"completed",continuationPort:"then"}}}}export class DestroyPrefabNode extends t{constructor(t){super(),this.instance=t}compileExecution(t){return{chunk:`runtime.destroyPrefab(${t.get(this.instance)})`,invalidatesValues:!0}}}export class DestroyActorNode extends t{constructor(t){super(),this.actor=t}compileExecution(t){return{chunk:`runtime.destroyActor(${t.get(this.actor)})`,invalidatesValues:!0}}}function r(t,e,r){const s=`${e}_${t.variable()}`;return{setup:`const ${s} = ${r}`,outputs:{value:s}}}function s(t){if("number"==typeof t&&!Number.isFinite(t))throw new Error("Event graph numbers must be finite");const e=JSON.stringify(t);if(null==e)throw new Error("Event graph value cannot be serialized to JavaScript");return e}function a(t,e){if("vector2"===e.kind){const e=t;return`runtime.createVector2(${s(e[0])}, ${s(e[1])})`}if("vector3"===e.kind){const e=t;return`runtime.createVector3(${s(e[0])}, ${s(e[1])}, ${s(e[2])})`}if("euler"===e.kind){const e=t;return`runtime.createEuler(${s(e[0])}, ${s(e[1])}, ${s(e[2])})`}return"asset"===e.kind?s(t.assetId):"actorClass"===e.kind?`runtime.actorClass(${s(t)})`:"optional"===e.kind?null===t?"null":a(t,e.value):"array"===e.kind&&Array.isArray(t)?`[${t.map(t=>a(t,e.element)).join(", ")}]`:s(t)}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/event-graph/nodes/index.d.ts

@@ -0,0 +1,4 @@
+export * from './execution-nodes.js';
+export * from './gameplay-nodes.js';
+export * from './value-nodes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gameplay/event-graph/nodes/index.js

@@ -0,0 +1,4 @@
+export*from"./execution-nodes.js";export*from"./gameplay-nodes.js";export*from"./value-nodes.js";/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/event-graph/nodes/value-nodes.d.ts

@@ -0,0 +1,53 @@
+import type { CompilationContext } from '../compiler.js';
+import { PureNode, type DataCompileResult, type ValueInput } from '../graph.js';
+export declare abstract class StringNode extends PureNode {
+    add(b: StringNode | string): StringNode;
+}
+export declare class ConstantStringNode extends StringNode {
+    readonly value: string;
+    constructor(value: string);
+    compileData(): DataCompileResult;
+}
+export declare abstract class NumberNode extends PureNode {
+    add(b: NumberNode | number): NumberNode;
+    asString(): StringNode;
+}
+export declare class AddNode extends NumberNode {
+    readonly a: NumberNode;
+    readonly b: NumberNode;
+    constructor(a: NumberNode, b: NumberNode);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class NumberToStringNode extends StringNode {
+    private readonly value;
+    constructor(value: NumberNode);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class ConcatNode extends StringNode {
+    readonly a: StringNode;
+    readonly b: StringNode;
+    constructor(a: StringNode, b: StringNode);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class ConstantNumberNode extends NumberNode {
+    readonly value: number;
+    constructor(value: number);
+    compileData(): DataCompileResult;
+}
+export declare class ThisNode extends PureNode {
+    compileData(): DataCompileResult;
+}
+export declare class VariableNode extends PureNode {
+    private readonly variable;
+    constructor(variable: string);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+export declare class SplitStringNode extends PureNode {
+    private readonly input;
+    private readonly delimiter;
+    readonly before: import("../graph.js").DataOutput<string>;
+    readonly after: import("../graph.js").DataOutput<string>;
+    constructor(input: ValueInput<string>, delimiter: ValueInput<string>);
+    compileData(c: CompilationContext): DataCompileResult;
+}
+//# sourceMappingURL=value-nodes.d.ts.map

package/dist/gameplay/event-graph/nodes/value-nodes.js

@@ -0,0 +1,4 @@
+import{PureNode as t}from"../graph.js";export class StringNode extends t{add(t){return new ConcatNode(this,"string"==typeof(e=t)?new ConstantStringNode(e):e);var e}}export class ConstantStringNode extends StringNode{constructor(t){super(),this.value=t}compileData(){return{outputs:{value:JSON.stringify(this.value)}}}}export class NumberNode extends t{add(t){return new AddNode(this,"number"==typeof(e=t)?new ConstantNumberNode(e):e);var e}asString(){return new NumberToStringNode(this)}}export class AddNode extends NumberNode{constructor(t,e){super(),this.a=t,this.b=e}compileData(t){const e=`sum_${t.variable()}`;return{setup:`const ${e} = (${t.get(this.a)} + ${t.get(this.b)})`,outputs:{value:`${e}`}}}}export class NumberToStringNode extends StringNode{constructor(t){super(),this.value=t}compileData(t){return{outputs:{value:`(${t.get(this.value)})?.toString()`}}}}export class ConcatNode extends StringNode{constructor(t,e){super(),this.a=t,this.b=e}compileData(t){return{outputs:{value:`(${t.get(this.a)} + ${t.get(this.b)})`}}}}export class ConstantNumberNode extends NumberNode{constructor(t){super(),this.value=t}compileData(){return{outputs:{value:this.value.toString()}}}}export class ThisNode extends t{compileData(){return{outputs:{value:"this"}}}}export class VariableNode extends t{constructor(t){super(),this.variable=t}compileData(t){return{outputs:{value:t.getVariableName(this.variable)}}}}export class SplitStringNode extends t{constructor(t,e){super(),this.input=t,this.delimiter=e,this.before=this.output("before"),this.after=this.output("after")}compileData(t){const e=t.get(this.input),s=t.get(this.delimiter),r=`split_${t.variable()}`;return{setup:`const ${r} = ${e}.split(${s})`,outputs:{before:`(${r}[0] ?? "")`,after:`${r}.slice(1).join(${s})`}}}}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/gameplay/event-graph/registry.d.ts

@@ -0,0 +1,33 @@
+import type { EventGraphNode, EventGraphNodeKind, EventGraphSerializableValue } from './model.js';
+import { type EventGraphType } from './types.js';
+export type EventGraphValueType = EventGraphType;
+export interface EventGraphPortDefinition {
+    name: string;
+    kind: 'execution' | 'data';
+    type?: EventGraphType;
+    label?: string;
+    optional?: boolean;
+    /** Effective fallback used when the document does not author a value for this input. */
+    defaultValue?: EventGraphSerializableValue;
+}
+export interface EventGraphNodeDefinition {
+    kind: EventGraphNodeKind;
+    label: string;
+    category: string;
+    inputs: EventGraphPortDefinition[];
+    outputs: EventGraphPortDefinition[];
+    pure?: boolean;
+    event?: boolean;
+    /** Execution output names are declared by node parameters. */
+    dynamicExecutionOutputs?: boolean;
+}
+export interface EventGraphPortTypeResolver {
+    getOutputType(nodeId: string, port: string): EventGraphType;
+}
+export declare const EVENT_GRAPH_NODE_DEFINITIONS: Record<EventGraphNodeKind, EventGraphNodeDefinition>;
+/** Resolves the effective static and parameter-defined ports for compilers and editors. */
+export declare function getEventGraphNodePorts(node: EventGraphNode, side: 'inputs' | 'outputs', types?: EventGraphPortTypeResolver | null): EventGraphPortDefinition[];
+export declare function getEventGraphPortDefinition(node: EventGraphNode, port: string, side: 'inputs' | 'outputs', types?: EventGraphPortTypeResolver | null): EventGraphPortDefinition | undefined;
+/** Returns the core-owned fallback for an input, or undefined when the input must be authored. */
+export declare function getEventGraphInputDefault(node: EventGraphNode, port: string): EventGraphSerializableValue | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/gameplay/event-graph/registry.js

@@ -0,0 +1,4 @@
+import{EVENT_GRAPH_ACTOR_TYPE as e,EVENT_GRAPH_ACTOR_CLASS_TYPE as a,EVENT_GRAPH_ANY_TYPE as t,EVENT_GRAPH_BOOLEAN_TYPE as n,EVENT_GRAPH_COMPONENT_TYPE as o,EVENT_GRAPH_ROTATION_TYPE as l,EVENT_GRAPH_NUMBER_TYPE as r,EVENT_GRAPH_OBJECT_TYPE as d,EVENT_GRAPH_STRING_TYPE as i,EVENT_GRAPH_VECTOR2_TYPE as u,EVENT_GRAPH_VECTOR3_TYPE as s,eventGraphAssetType as p,eventGraphOptionalType as c}from"./types.js";const m={name:"exec",kind:"execution"},y={name:"then",kind:"execution"},f={name:"value",kind:"data",type:t},b={name:"target",kind:"data",type:d},k={name:"value",kind:"data",type:t},g=p("prefab"),v=p("vfx"),h=p("sequence"),V={kind:"object",classId:"PrefabInstance"},w={kind:"object",classId:"EventGraphTimer"};function x(e,a,n,o,l){return{kind:e,label:a,category:n,pure:!0,inputs:[{name:"a",kind:"data",type:t,...null!=l?{defaultValue:l[0]}:{}},{name:"b",kind:"data",type:t,...null!=l?{defaultValue:l[1]}:{}}],outputs:[{...f,type:o}]}}export const EVENT_GRAPH_NODE_DEFINITIONS={"event.beginPlay":T("event.beginPlay","Begin Play"),"event.update":{...T("event.update","Update"),outputs:[y,{name:"deltaTime",label:"Delta Seconds",kind:"data",type:r}]},"event.endPlay":T("event.endPlay","End Play"),"event.observable":{...T("event.observable","Observable"),outputs:[y,f]},"event.source":{...T("event.source","Event Source"),outputs:[y,f]},"event.bindSource":{...C("event.bindSource","Bind Event Source","Events",[{name:"target",label:"Target",kind:"data",type:d}]),outputs:[y,{name:"triggered",label:"Triggered",kind:"execution"},f]},"flow.branch":{kind:"flow.branch",label:"Branch",category:"Flow",inputs:[m,{name:"condition",kind:"data",type:n,defaultValue:!1}],outputs:[{name:"true",kind:"execution"},{name:"false",kind:"execution"},y]},"flow.sequence":{kind:"flow.sequence",label:"Sequence",category:"Flow",inputs:[m],outputs:[y],dynamicExecutionOutputs:!0},"flow.parallel":{kind:"flow.parallel",label:"Parallel",category:"Flow",inputs:[m],outputs:[y],dynamicExecutionOutputs:!0},"flow.switch":{kind:"flow.switch",label:"Switch",category:"Flow",inputs:[m,{...k,defaultValue:""}],outputs:[y,{name:"default",kind:"execution"}],dynamicExecutionOutputs:!0},"flow.delay":C("flow.delay","Delay","Flow",[{name:"durationMs",kind:"data",type:r,defaultValue:0}]),"flow.interval":{kind:"flow.interval",label:"Interval",category:"Flow",inputs:[m,{name:"intervalMs",label:"Interval (ms)",kind:"data",type:r,defaultValue:1e3}],outputs:[y,{name:"interval",label:"Interval",kind:"execution"},{name:"timerId",label:"Timer",kind:"data",type:w}]},"flow.clearInterval":C("flow.clearInterval","Clear Interval","Flow",[{name:"timerId",label:"Timer",kind:"data",type:w}]),"flow.forLoop":{kind:"flow.forLoop",label:"For Loop",category:"Flow",inputs:[m,{name:"firstIndex",label:"First Index",kind:"data",type:r,defaultValue:0},{name:"lastIndex",label:"Last Index",kind:"data",type:r,defaultValue:0}],outputs:[{name:"loopBody",label:"Loop Body",kind:"execution"},{name:"completed",label:"Completed",kind:"execution"},{name:"index",label:"Index",kind:"data",type:r}]},"flow.isValid":{kind:"flow.isValid",label:"Is Valid",category:"Flow",inputs:[m,{...k,type:c(t)}],outputs:[{name:"valid",kind:"execution"},{name:"invalid",kind:"execution"},y,f]},"flow.forEach":{kind:"flow.forEach",label:"For Each",category:"Flow",inputs:[m,{name:"array",label:"Array",kind:"data",type:{kind:"array",element:t}}],outputs:[{name:"loopBody",label:"Loop Body",kind:"execution"},{name:"completed",label:"Completed",kind:"execution"},{name:"arrayElement",label:"Array Element",kind:"data",type:t},{name:"arrayIndex",label:"Array Index",kind:"data",type:r}]},"flow.doOnce":{kind:"flow.doOnce",label:"Do Once",category:"Flow",inputs:[m,{name:"reset",label:"Reset",kind:"execution"},{name:"startClosed",label:"Start Closed",kind:"data",type:n,defaultValue:!1}],outputs:[y]},"flow.gate":{kind:"flow.gate",label:"Gate",category:"Flow",inputs:[{name:"enter",label:"Enter",kind:"execution"},{name:"open",label:"Open",kind:"execution"},{name:"close",label:"Close",kind:"execution"},{name:"toggle",label:"Toggle",kind:"execution"},{name:"startClosed",label:"Start Closed",kind:"data",type:n,defaultValue:!1}],outputs:[{name:"exit",label:"Exit",kind:"execution"}]},"debug.log":C("debug.log","Log","Debug",[{...k,defaultValue:""}]),"constant.boolean":A("constant.boolean","Boolean",n),"constant.number":A("constant.number","Number",r),"constant.string":A("constant.string","String",i),"constant.vector2":A("constant.vector2","Vector2",u),"constant.vector3":A("constant.vector3","Vector3",s),"math.add":x("math.add","Add","Math",t,[0,0]),"math.subtract":x("math.subtract","Subtract","Math",t,[0,0]),"math.multiply":x("math.multiply","Multiply","Math",t,[1,1]),"math.divide":x("math.divide","Divide","Math",t,[0,1]),"math.modulo":x("math.modulo","Modulo","Math",t,[0,1]),"vector.length":E("vector.length","Length","Vectors",[{...k,type:t}],r),"vector.lengthSquared":E("vector.lengthSquared","Length Squared","Vectors",[{...k,type:t}],r),"vector.distance":E("vector.distance","Distance","Vectors",[{name:"a",kind:"data",type:t},{name:"b",kind:"data",type:t}],r),"vector.distanceSquared":E("vector.distanceSquared","Distance Squared","Vectors",[{name:"a",kind:"data",type:t},{name:"b",kind:"data",type:t}],r),"vector.normalize":E("vector.normalize","Normalize","Vectors",[{...k,type:t}],t),"vector.dot":E("vector.dot","Dot Product","Vectors",[{name:"a",kind:"data",type:t},{name:"b",kind:"data",type:t}],r),"vector.cross":E("vector.cross","Cross Product","Vectors",[{name:"a",kind:"data",type:s,defaultValue:[1,0,0]},{name:"b",kind:"data",type:s,defaultValue:[0,1,0]}],s),"vector.lerp":E("vector.lerp","Lerp","Vectors",[{name:"a",kind:"data",type:t},{name:"b",kind:"data",type:t},{name:"alpha",kind:"data",type:r,defaultValue:.5}],t),"vector.applyRotation":E("vector.applyRotation","Apply Rotation","Vectors",[{...k,type:s,defaultValue:[0,0,1]},{name:"rotation",kind:"data",type:l,defaultValue:[0,0,0]}],s),"compare.equal":x("compare.equal","Equal","Comparison",n),"compare.notEqual":x("compare.notEqual","Not Equal","Comparison",n),"compare.greaterThan":x("compare.greaterThan","Greater Than","Comparison",n,[0,0]),"compare.greaterThanOrEqual":x("compare.greaterThanOrEqual","Greater Than Or Equal","Comparison",n,[0,0]),"compare.lessThan":x("compare.lessThan","Less Than","Comparison",n,[0,0]),"compare.lessThanOrEqual":x("compare.lessThanOrEqual","Less Than Or Equal","Comparison",n,[0,0]),"boolean.and":x("boolean.and","And","Boolean",n,[!1,!0]),"boolean.or":x("boolean.or","Or","Boolean",n,[!1,!1]),"boolean.not":{kind:"boolean.not",label:"Not",category:"Boolean",pure:!0,inputs:[{...k,defaultValue:!1}],outputs:[{...f,type:n}]},"variable.get":E("variable.get","Get Variable","Variables",[],t),"variable.set":C("variable.set","Set Variable","Variables",[k]),"actor.reference":E("actor.reference","Actor Reference","Actors",[],e),"actor.component":E("actor.component","Get Component","Actors",[b],o),"actor.getProperty":E("actor.getProperty","Get Property","Actors",[b],t),"actor.setProperty":C("actor.setProperty","Set Property","Actors",[b,k]),"actor.tweenProperty":{...C("actor.tweenProperty","Tween Property","Actors",[{name:"target",label:"Target",kind:"data",type:e},{name:"to",label:"To",kind:"data",type:t},{name:"duration",label:"Duration (s)",kind:"data",type:r,defaultValue:1}]),outputs:[y,{name:"completed",label:"Completed",kind:"execution"}]},"transform.moveTo":P("transform.moveTo","Move To",[{name:"position",label:"Position",kind:"data",type:s,defaultValue:[0,0,0]}]),"transform.moveBy":P("transform.moveBy","Move By",[{name:"offset",label:"Offset",kind:"data",type:s,defaultValue:[0,0,0]}]),"transform.rotateTo":P("transform.rotateTo","Rotate To",[{name:"rotation",label:"Rotation",kind:"data",type:l,defaultValue:[0,0,0]}]),"transform.rotateBy":P("transform.rotateBy","Rotate By",[{name:"angle",label:"Angle (deg)",kind:"data",type:r,defaultValue:0}]),"transform.scaleTo":P("transform.scaleTo","Scale To",[{name:"scale",label:"Scale",kind:"data",type:s,defaultValue:[1,1,1]}]),"transform.scaleBy":P("transform.scaleBy","Scale By",[{name:"factor",label:"Factor",kind:"data",type:s,defaultValue:[1,1,1]}]),"actor.callMethod":{...C("actor.callMethod","Call Method","Actors",[b]),outputs:[y,f]},"actor.tryCallMethod":{...C("actor.tryCallMethod","Try Call Method","Actors",[b]),outputs:[{name:"success",kind:"execution"},{name:"error",kind:"execution"},y,f,{name:"errorValue",kind:"data",type:t}]},"actor.findByType":E("actor.findByType","Find Actor by Type","Actors",[{name:"actorClass",label:"Actor Class",kind:"data",type:a}],c(e)),"actor.findAllByType":E("actor.findAllByType","Find Actors by Type","Actors",[{name:"actorClass",label:"Actor Class",kind:"data",type:a}],{kind:"array",element:e}),"actor.spawnClass":{...C("actor.spawnClass","Spawn Actor Class","Gameplay",[]),outputs:[y,{...f,type:e}]},"actor.spawnPrefab":{...C("actor.spawnPrefab","Spawn Prefab","Gameplay",[{name:"prefab",label:"Prefab",kind:"data",type:g},{name:"position",label:"Position",kind:"data",type:s,defaultValue:[0,0,0]},{name:"rotation",label:"Rotation",kind:"data",type:l,defaultValue:[0,0,0]}]),outputs:[y,{name:"instance",label:"Instance",kind:"data",type:V},{name:"mainActor",label:"Main Actor",kind:"data",type:c(e)}]},"actor.destroy":C("actor.destroy","Destroy Actor","Gameplay",[{name:"actor",label:"Actor",kind:"data",type:e}]),"asset.reference":E("asset.reference","Asset Reference","Assets",[],t),"vfx.play":{...C("vfx.play","Play VFX","Effects",[{name:"vfx",label:"VFX",kind:"data",type:v},{name:"position",label:"Position",kind:"data",type:s,defaultValue:[0,0,0]},{name:"rotation",label:"Rotation",kind:"data",type:l,defaultValue:[0,0,0]},{name:"autoDestroy",label:"Auto Destroy",kind:"data",type:n,defaultValue:!0}]),outputs:[y,{name:"completed",label:"Completed",kind:"execution"},{...f,label:"VFX Actor",type:e}]},"sequence.play":{...C("sequence.play","Play Sequence","Effects",[{name:"sequence",label:"Sequence",kind:"data",type:h},{name:"target",label:"Target",kind:"data",type:c(e),defaultValue:null},{name:"cameraControlEnabled",label:"Camera Control",kind:"data",type:n,defaultValue:!1},{name:"autoDestroy",label:"Auto Destroy",kind:"data",type:n,defaultValue:!0}]),outputs:[y,{name:"completed",label:"Completed",kind:"execution"},{...f,label:"Sequence Actor",type:e}]},"prefab.destroy":C("prefab.destroy","Destroy Prefab","Gameplay",[{name:"instance",label:"Instance",kind:"data",type:V}])};export function getEventGraphNodePorts(e,a,n){const o=EVENT_GRAPH_NODE_DEFINITIONS[e.kind][a].map(e=>({...e}));if("inputs"===a&&("actor.callMethod"===e.kind||"actor.tryCallMethod"===e.kind||"event.bindSource"===e.kind)){const a="number"==typeof e.params?.argumentCount&&Number.isInteger(e.params.argumentCount)?Math.max(0,e.params.argumentCount):0,n=Array.isArray(e.params?.argumentLabels)?e.params.argumentLabels.filter(e=>"string"==typeof e):[];for(let e=0;e<a;e++){const a=null!=n[e]&&n[e].length>0?n[e]:`Argument ${e+1}`;o.push({name:`arg${e}`,label:a,kind:"data",type:t})}}return"outputs"!==a||"flow.sequence"!==e.kind&&"flow.parallel"!==e.kind||!Array.isArray(e.params?.ports)||o.unshift(...e.params.ports.filter(e=>"string"==typeof e).map(e=>({name:e,label:e,kind:"execution"}))),"outputs"===a&&"flow.switch"===e.kind&&Array.isArray(e.params?.cases)&&o.unshift(...e.params.cases.flatMap(e=>{return null==e||Array.isArray(e)||"object"!=typeof e||"string"!=typeof e.port?[]:[{name:e.port,label:(a=e.value,"string"==typeof a?a:JSON.stringify(a)),kind:"execution"}];var a})),"outputs"===a&&null!=n?o.filter(a=>"data"!==a.kind||"void"!==n.getOutputType(e.id,a.name).kind):o}export function getEventGraphPortDefinition(e,a,t,n){return getEventGraphNodePorts(e,t,n).find(e=>e.name===a)}export function getEventGraphInputDefault(e,a){return getEventGraphPortDefinition(e,a,"inputs")?.defaultValue}function T(e,a){return{kind:e,label:a,category:"Events",event:!0,inputs:[],outputs:[y]}}function A(e,a,t){return{kind:e,label:a,category:"Constants",pure:!0,inputs:[],outputs:[{...f,type:t}]}}function E(e,a,t,n,o){return{kind:e,label:a,category:t,pure:!0,inputs:n,outputs:[{...f,type:o}]}}function C(e,a,t,n){return{kind:e,label:a,category:t,inputs:[m,...n],outputs:[y]}}function P(a,t,n){return{...C(a,t,"Transforms",[{name:"target",label:"Target",kind:"data",type:e},...n,{name:"duration",label:"Duration (s)",kind:"data",type:r,defaultValue:1}]),outputs:[y,{name:"completed",label:"Completed",kind:"execution"}]}}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */