@hology/core 0.0.211 → 0.0.213

package/dist/gameplay/event-graph/document-compiler.d.ts

@@ -0,0 +1,107 @@
+import type { Euler, Vector2, Vector3 } from 'three';
+import type { EventGraphDocument, EventGraphTransformAxis, EventGraphTransformSpace } from './model.js';
+import { type EventGraphTypeAnalysis, type EventGraphTypeContext } from './type-inference.js';
+export type EventGraphHandler = (runtime: EventGraphExecutionContext, eventValue?: unknown) => unknown;
+export interface EventGraphExecutionContext {
+    actor(id: string): unknown;
+    component(target: unknown, property: string): unknown;
+    getProperty(target: unknown, property: string): unknown;
+    setProperty(target: unknown, property: string, value: unknown): void;
+    tweenProperty(target: unknown, property: string, to: unknown, duration: number, curve: string, completed: (() => unknown) | undefined, eventNodeId: string): void;
+    tweenMoveTo(target: unknown, position: Vector3, duration: number, curve: string, space: EventGraphTransformSpace, completed: (() => unknown) | undefined, eventNodeId: string): void;
+    tweenMoveBy(target: unknown, offset: Vector3, duration: number, curve: string, space: EventGraphTransformSpace, completed: (() => unknown) | undefined, eventNodeId: string): void;
+    tweenRotateTo(target: unknown, rotation: Euler, duration: number, curve: string, space: EventGraphTransformSpace, completed: (() => unknown) | undefined, eventNodeId: string): void;
+    tweenRotateBy(target: unknown, angleDegrees: number, duration: number, curve: string, space: EventGraphTransformSpace, axis: EventGraphTransformAxis, completed: (() => unknown) | undefined, eventNodeId: string): void;
+    tweenScaleTo(target: unknown, scale: Vector3, duration: number, curve: string, completed: (() => unknown) | undefined, eventNodeId: string): void;
+    tweenScaleBy(target: unknown, factor: Vector3, duration: number, curve: string, completed: (() => unknown) | undefined, eventNodeId: string): void;
+    callMethod(target: unknown, method: string, args: unknown[]): unknown;
+    actorClass(classId: string): unknown;
+    findActorByType(actorClass: unknown): unknown;
+    findActorsByType(actorClass: unknown): unknown[];
+    bindEventSource(nodeId: string, target: unknown, method: string, args: unknown[], callback: ((value: unknown) => unknown) | undefined, eventNodeId: string): void;
+    spawnActor(classId: string): Promise<unknown>;
+    spawnPrefab(assetId: string, position: Vector3, rotation: Euler): Promise<{
+        instance: unknown;
+        mainActor: unknown | null;
+    }>;
+    playVfx(assetId: string, position: Vector3, rotation: Euler, autoDestroy: boolean): Promise<unknown>;
+    playSequence(assetId: string, target: unknown | null, cameraControlEnabled: boolean, autoDestroy: boolean): Promise<unknown>;
+    onActorCompleted(actor: unknown, callback: () => unknown, eventNodeId: string): void;
+    destroyPrefab(instance: unknown): void;
+    destroyActor(actor: unknown): void;
+    getVariable(name: string): unknown;
+    setVariable(name: string, value: unknown): void;
+    delay(durationMs: number): Promise<void>;
+    setInterval(nodeId: string, intervalMs: number, callback: (() => unknown) | undefined, eventNodeId: string): number | undefined;
+    clearInterval(intervalId: number): void;
+    doOnce(nodeId: string, entryPort: string, startClosed: boolean): boolean;
+    gate(nodeId: string, entryPort: string, startClosed: boolean): boolean;
+    readValue(value: unknown): unknown;
+    mathAdd(a: unknown, b: unknown): unknown;
+    mathSubtract(a: unknown, b: unknown): unknown;
+    mathMultiply(a: unknown, b: unknown): unknown;
+    mathDivide(a: unknown, b: unknown): unknown;
+    mathModulo(a: unknown, b: unknown): unknown;
+    vectorLength(value: unknown): number;
+    vectorLengthSquared(value: unknown): number;
+    vectorDistance(a: unknown, b: unknown): number;
+    vectorDistanceSquared(a: unknown, b: unknown): number;
+    vectorNormalize(value: unknown): unknown;
+    vectorDot(a: unknown, b: unknown): number;
+    vectorCross(a: unknown, b: unknown): Vector3;
+    vectorLerp(a: unknown, b: unknown, alpha: number): unknown;
+    vectorApplyRotation(value: unknown, rotation: Euler): Vector3;
+    createVector2(x: number, y: number): Vector2;
+    createVector3(x: number, y: number, z: number): Vector3;
+    createEuler(x: number, y: number, z: number): Euler;
+}
+export interface CompiledEventGraphHandler {
+    eventNodeId: string;
+    source: string;
+    async: boolean;
+    invoke: EventGraphHandler;
+}
+export interface CompiledObservableEvent extends CompiledEventGraphHandler {
+    actorId: string;
+    component?: string;
+    property: string;
+}
+export type CompiledEventSourceArgument = {
+    kind: 'actor';
+    actorId: string;
+} | {
+    kind: 'actorClass';
+    classId: string;
+};
+export interface CompiledEventSourceEvent extends CompiledEventGraphHandler {
+    actorId: string;
+    component?: string;
+    method: string;
+    args: CompiledEventSourceArgument[];
+}
+export interface CompiledEventGraph {
+    beginPlay: CompiledEventGraphHandler[];
+    update: CompiledEventGraphHandler[];
+    endPlay: CompiledEventGraphHandler[];
+    observables: CompiledObservableEvent[];
+    eventSources: CompiledEventSourceEvent[];
+}
+export interface EventGraphDiagnostic {
+    code: string;
+    severity: 'error' | 'warning';
+    nodeId?: string;
+    portId?: string;
+    path: readonly (string | number)[];
+    message: string;
+}
+export interface EventGraphValidationResult {
+    diagnostics: readonly EventGraphDiagnostic[];
+    typeAnalysis: EventGraphTypeAnalysis | null;
+}
+/** Validates a persisted document, lowers it into node IR, and compiles each event entry point. */
+export declare class EventGraphCompiler {
+    compile(graph: EventGraphDocument, typeContext?: EventGraphTypeContext): CompiledEventGraph;
+}
+/** Runs the same structural and type checks used by compilation without throwing. */
+export declare function validateEventGraphDocument(graph: EventGraphDocument, typeContext?: EventGraphTypeContext): EventGraphValidationResult;
+//# sourceMappingURL=document-compiler.d.ts.map

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

@@ -0,0 +1,4 @@
+import{getActorClassById as e,getComponentClassById as t}from"../actors/type-registry.js";import{collectEventGraphAssetReferences as n,isEventGraphAssetReference as r}from"./asset-references.js";import{Compiler as o}from"./compiler.js";import{ExecutionNode as i,PureNode as s}from"./graph.js";import{normalizeEventGraphDocument as a}from"./model.js";import{EVENT_GRAPH_NODE_DEFINITIONS as u,getEventGraphInputDefault as d,getEventGraphNodePorts as c,getEventGraphPortDefinition as l}from"./registry.js";import{isEventGraphLiteralAssignableToType as p,isEventGraphType as h}from"./types.js";import{analyzeEventGraphTypes as f}from"./type-inference.js";import{BranchNode as w,ClearIntervalNode as m,DelayNode as g,DoOnceNode as y,ForLoopNode as v,GateNode as N,IntervalNode as E,ForEachNode as $,LogNode as k,ParallelNode as S,SequenceNode as b,IsValidNode as I,SelectNode as O,StartNode as J}from"./nodes/execution-nodes.js";import{ActorReferenceNode as x,AssetReferenceNode as A,BinaryOperatorNode as T,CallMethodNode as q,ComponentReferenceNode as C,DestroyActorNode as j,DestroyPrefabNode as M,EventValueNode as P,BindEventSourceNode as R,FindActorByTypeNode as B,FindActorsByTypeNode as z,GetPropertyNode as V,GraphVariableNode as D,LiteralNode as L,NotNode as F,PlaySequenceNode as G,PlayVfxNode as U,RuntimeCallbackNode as W,RuntimeLiteralNode as _,SetGraphVariableNode as H,SetPropertyNode as K,SpawnActorNode as Q,SpawnPrefabNode as X,TryCallMethodNode as Y,VectorApplyRotationNode as Z,VectorBinaryOperatorNode as ee,VectorEqualityNode as te,VectorLerpNode as ne,VectorMathOperatorNode as re,VectorUnaryOperatorNode as oe}from"./nodes/gameplay-nodes.js";import{getEventGraphEventSourceInfo as ie,getEventGraphPropertyInfo as se}from"./decorators.js";const ae=Object.getPrototypeOf(async function(){}).constructor;export class EventGraphCompiler{compile(e,t={}){const n=ue(e=a(e),t),r=n.result.diagnostics.filter(e=>"error"===e.severity);if(r.length>0||null==n.document)throw new Error(`Event graph validation failed:\n${r.map(de).join("\n")}`);const o=n.document,i=n.result.typeAnalysis,s={beginPlay:[],update:[],endPlay:[],observables:[],eventSources:[]};for(const n of e.nodes){if(!0!==u[n.kind].event)continue;const e=new le(o,n,i).compile();if("event.beginPlay"===n.kind&&s.beginPlay.push(e),"event.update"===n.kind&&s.update.push(e),"event.endPlay"===n.kind&&s.endPlay.push(e),"event.observable"===n.kind){const t=Je(n,"component");s.observables.push({...e,actorId:Oe(n,"actorId"),property:Oe(n,"property"),...null!=t?{component:t}:{}})}if("event.source"===n.kind){const r=Je(n,"component"),o=Oe(n,"source"),i=he(pe(n,t),o);s.eventSources.push({...e,actorId:Oe(n,"actorId"),method:o,args:fe(n,i),...null!=r?{component:r}:{}})}}return s}}export function validateEventGraphDocument(e,t={}){return ue(e,t).result}function ue(e,t){e=a(e);const r=[],o=new ce(e);let i=!0;try{o.validate()}catch(e){i=!1,r.push({code:"invalid-structure",severity:"error",path:[],message:e instanceof Error?e.message:String(e)})}i&&r.push(...function(e){const t=new Map(e.nodes.map(e=>[e.id,e])),n=[];for(const r of["data","execution"]){const o=new Map;for(const n of e.edges){const e=t.get(n.from.nodeId);if(null==e||l(e,n.from.port,"outputs")?.kind!==r)continue;const i=o.get(n.from.nodeId)??[];i.push(n),o.set(n.from.nodeId,i)}const i=new Set,s=new Set;let a;const u=e=>{if(i.has(e))return!0;if(s.has(e))return!1;i.add(e);for(const t of o.get(e)??[])if(u(t.to.nodeId))return a=t,!0;return i.delete(e),s.add(e),!1};for(const t of e.nodes)if(u(t.id))break;null!=a&&n.push({code:`${r}-cycle`,severity:"error",nodeId:a.to.nodeId,portId:a.to.port,path:["edges"],message:`Event graph contains a ${r} cycle`})}return n}(e)),i&&r.push(...function(e,t){return null==t.resolveAssetType?[]:n(e).flatMap(e=>{const n=t.resolveAssetType(e.reference.assetId);return void 0===n?[{code:"missing-asset",severity:"error",...null!=e.nodeId?{nodeId:e.nodeId}:{},...null!=e.portId?{portId:e.portId}:{},path:e.path,message:`Asset ${JSON.stringify(e.reference.assetId)} does not exist`}]:n!==e.reference.assetType?[{code:"wrong-asset-type",severity:"error",...null!=e.nodeId?{nodeId:e.nodeId}:{},...null!=e.portId?{portId:e.portId}:{},path:e.path,message:`Expected ${e.reference.assetType} asset, received ${n}`}]:[]})}(e,t));let s=null;if(i)try{s=f(e,t),r.push(...function(e,t){const n=new Set(e.edges.map(e=>Te(e.to))),r=[];for(const o of e.nodes)for(const e of c(o,"inputs"))"data"===e.kind&&!0!==e.optional&&(null!=o.inputs?.[e.name]||n.has(Te({nodeId:o.id,port:e.name}))||void 0===d(o,e.name)&&(ke(o)&&void 0!==Se(t.getInputType(o.id,e.name))||r.push({code:"missing-input",severity:"error",nodeId:o.id,portId:e.name,path:["nodes",o.id,"inputs",e.name],message:`Required input ${JSON.stringify(e.label??e.name)} is not connected and has no fallback value`})));return r}(e,s),...function(e,t){const n=new Map(e.nodes.map(e=>[e.id,e])),r=[],o=new Set,i=e=>{const i=n.get(e.nodeId);if(null==i||null!=l(i,e.port,"outputs",t))return;const s=Te(e);o.has(s)||(o.add(s),r.push({code:"unavailable-output-port",severity:"error",nodeId:i.id,portId:e.port,path:["nodes",i.id,"outputs",e.port],message:`Output ${JSON.stringify(e.port)} is unavailable for its inferred type`}))};for(const t of e.edges)i(t.from);for(const t of e.nodes)for(const e of Object.values(t.inputs??{}))"nodeId"in e&&i(e);return r}(e,s)),r.push(...s.diagnostics.map(e=>({code:"incompatible-type",severity:e.severity,nodeId:e.nodeId,...null!=e.port?{portId:e.port}:{},path:["nodes",e.nodeId,...null!=e.port?["inputs",e.port]:[]],message:e.message})))}catch(e){r.push({code:"type-analysis-failed",severity:"error",path:[],message:e instanceof Error?e.message:String(e)})}return{result:{diagnostics:r,typeAnalysis:s},document:i?o:null}}function de(e){const t=null==e.nodeId?"":` at ${e.nodeId}${null!=e.portId?`:${e.portId}`:""}`;return`[${e.code}]${t} ${e.message}`}class ce{constructor(e){this.graph=e,this.nodes=new Map,this.variables=new Set,this.incomingEdges=new Map,this.executionEdges=new Map}validate(){if(1!==this.graph.version)throw new Error(`Unsupported event graph version ${String(this.graph.version)}`);for(const e of this.graph.variables??[]){if(0===e.name.trim().length)throw new Error("Event graph variable names must not be empty");if(this.variables.has(e.name))throw new Error(`Duplicate event graph variable ${JSON.stringify(e.name)}`);if(null!=e.type&&!h(e.type))throw new Error(`Event graph variable ${JSON.stringify(e.name)} has an invalid type`);if(null!=e.type&&void 0!==e.defaultValue&&!p(e.defaultValue,e.type))throw new Error(`Event graph variable ${JSON.stringify(e.name)} has an incompatible default value`);this.variables.add(e.name)}for(const e of this.graph.nodes){if(this.nodes.has(e.id))throw new Error(`Duplicate event graph node id ${JSON.stringify(e.id)}`);if(null==u[e.kind])throw new Error(`Unknown event graph node kind ${JSON.stringify(e.kind)}`);if(this.nodes.set(e.id,e),e.kind.startsWith("constant.")&&Ee(e),"asset.reference"===e.kind&&!r(e.params?.reference))throw new Error(`Asset Reference node ${JSON.stringify(e.id)} requires a valid reference`);"flow.sequence"!==e.kind&&"flow.parallel"!==e.kind||ye(e),"flow.switch"===e.kind&&ve(e)}for(const e of this.graph.edges){const t=this.getNode(e.from.nodeId),n=this.getNode(e.to.nodeId),r=Ne(t,e.from.port,"outputs"),o=Ne(n,e.to.port,"inputs");if(r.kind!==o.kind)throw new Error(`Event graph edge ${qe(e)} mixes data and execution ports`);if("data"===o.kind){const t=Te(e.to);if(this.incomingEdges.has(t))throw new Error(`Event graph input ${JSON.stringify(t)} has more than one connection`);this.incomingEdges.set(t,e)}if("execution"===r.kind){const t=Te(e.from);if(this.executionEdges.has(t))throw new Error(`Execution output ${JSON.stringify(t)} has more than one connection`);if(!0===u[n.kind].event)throw new Error("Event nodes cannot be reached through execution inputs");this.executionEdges.set(t,e)}}for(const e of this.graph.nodes)for(const[t,n]of Object.entries(e.inputs??{})){if("data"!==Ne(e,t,"inputs").kind)throw new Error(`Explicit node input ${JSON.stringify(`${e.id}:${t}`)} must be a data port`);if("nodeId"in n){if("data"!==Ne(this.getNode(n.nodeId),n.port,"outputs").kind)throw new Error(`Explicit node input ${JSON.stringify(`${e.id}:${t}`)} references an execution port`)}}}getNode(e){const t=this.nodes.get(e);if(null==t)throw new Error(`Event graph references missing node ${JSON.stringify(e)}`);return t}getInput(e,t){const n=this.incomingEdges.get(Te({nodeId:e.id,port:t}))?.from??e.inputs?.[t];if(null!=n)return n;const r=d(e,t);return void 0!==r?{value:r}:void 0}getExecutionTarget(e,t){const n=this.executionEdges.get(Te({nodeId:e.id,port:t}));return null!=n?{node:this.getNode(n.to.nodeId),inputPort:n.to.port}:void 0}}class le{constructor(e,t,n){this.document=e,this.eventNode=t,this.typeAnalysis=n,this.compiler=new o,this.loweredNodes=new Map,this.loweringNodes=new Set,this.connectedExecutionNodes=new Set,this.loweredExecutionNodes=new Map,this.eventValues=new Map}compile(){const e=new J;e.id=this.eventNode.id,this.connectExecutionOutputs(this.eventNode,e);const t=this.compiler.compile(e),n=`"use strict"\n${t.source}`,r=t.async?ae:Function;return{eventNodeId:this.eventNode.id,source:n,async:t.async,invoke:new r("runtime","eventValue",n)}}connectExecutionOutputs(e,t,n="exec"){const r=`${e.id}:${n}`;if(this.connectedExecutionNodes.has(r))return;this.connectedExecutionNodes.add(r);const o=c(e,"outputs").filter(e=>"execution"===e.kind).map(e=>e.name);for(const n of o){const r=this.document.getExecutionTarget(e,n);if(null==r)continue;const o=this.lowerExecutionNode(r.node,r.inputPort);t.connect(n,o),this.connectExecutionOutputs(r.node,o,r.inputPort)}}lowerExecutionNode(e,t="exec"){const n=`${e.id}:${t}`,r=this.loweredExecutionNodes.get(n);if(null!=r)return r;const o=this.lowerNode(e,t);if(!(o instanceof i))throw new Error(`Node ${JSON.stringify(e.id)} cannot be placed on an execution line`);return this.loweredExecutionNodes.set(n,o),o}lowerNode(e,t="exec"){const n=this.loweredNodes.get(e.id),r="flow.doOnce"===e.kind||"flow.gate"===e.kind;if(null!=n&&!r)return n;if(this.loweringNodes.has(e.id))throw new Error(`Circular data dependency at ${JSON.stringify(e.id)}`);if(!0===u[e.kind].event)throw new Error(`Event node ${JSON.stringify(e.id)} cannot be lowered as a regular node`);this.loweringNodes.add(e.id);try{const n=this.createNode(e,t);return n.id=e.id,r||this.loweredNodes.set(e.id,n),n}finally{this.loweringNodes.delete(e.id)}}createNode(e,t="exec"){if(e.kind.startsWith("constant.")){const t=Ee(e),n=this.typeAnalysis.getOutputType(e.id,"value");return $e(n)?new _(t,n):new L(t)}if("compare.equal"===e.kind||"compare.notEqual"===e.kind){const t=this.typeAnalysis.getInputType(e.id,"a");if("vector2"===t.kind||"vector3"===t.kind||"euler"===t.kind)return new te(this.input(e,"a"),this.input(e,"b"),"compare.notEqual"===e.kind)}const n={"math.add":"+","math.subtract":"-","math.multiply":"*","math.divide":"/","math.modulo":"%","compare.equal":"===","compare.notEqual":"!==","compare.greaterThan":">","compare.greaterThanOrEqual":">=","compare.lessThan":"<","compare.lessThanOrEqual":"<=","boolean.and":"&&","boolean.or":"||"}[e.kind];if(null!=n){const t=function(e){return{"math.add":"add","math.subtract":"subtract","math.multiply":"multiply","math.divide":"divide","math.modulo":"modulo"}[e]}(e.kind),r=this.typeAnalysis.getOutputType(e.id,"value");return null==t||"vector2"!==r.kind&&"vector3"!==r.kind?new T(this.input(e,"a"),this.input(e,"b"),n):new re(this.input(e,"a"),this.input(e,"b"),t)}const o=function(e){return{"vector.length":"length","vector.lengthSquared":"lengthSquared","vector.normalize":"normalize"}[e]}(e.kind);if(null!=o)return new oe(this.input(e,"value"),o);const i=function(e){return{"vector.distance":"distance","vector.distanceSquared":"distanceSquared","vector.dot":"dot","vector.cross":"cross"}[e]}(e.kind);if(null!=i)return new ee(this.input(e,"a"),this.input(e,"b"),i);switch(e.kind){case"vector.lerp":return new ne(this.input(e,"a"),this.input(e,"b"),this.input(e,"alpha"));case"vector.applyRotation":return new Z(this.input(e,"value"),this.input(e,"rotation"));case"boolean.not":return new F(this.input(e,"value"));case"flow.branch":return new w(this.input(e,"condition"));case"flow.sequence":return new b(ye(e));case"flow.parallel":return new S(...ye(e));case"flow.switch":return new O(this.input(e,"value"),ve(e));case"flow.delay":return new g(this.input(e,"durationMs"));case"flow.interval":return new E(e.id,this.input(e,"intervalMs"));case"flow.clearInterval":return new m(this.input(e,"timerId"));case"flow.forLoop":return new v(this.input(e,"firstIndex"),this.input(e,"lastIndex"));case"flow.isValid":return new I(this.input(e,"value"));case"flow.forEach":return new $(this.input(e,"array"));case"flow.doOnce":return new y(e.id,t,this.input(e,"startClosed"));case"flow.gate":return new N(e.id,t,this.input(e,"startClosed"));case"debug.log":return new k(this.input(e,"value"));case"variable.get":{const t=Ie(e,this.document.variables);return new D(t)}case"variable.set":{const t=Ie(e,this.document.variables);return new H(t,this.input(e,"value"))}case"actor.reference":return new x(Oe(e,"actorId"));case"asset.reference":return new A(function(e){const t=e.params?.reference;if(!r(t)||0===t.assetId.length)throw new Error(`Node ${JSON.stringify(e.id)} requires a valid asset reference`);return t}(e).assetId);case"actor.component":return new C(this.input(e,"target"),Oe(e,"property"));case"actor.getProperty":return new V(this.input(e,"target"),Oe(e,"property"));case"actor.setProperty":return new K(this.input(e,"target"),Oe(e,"property"),this.input(e,"value"));case"actor.tweenProperty":return new W("tweenProperty",[this.input(e,"target"),Oe(e,"property"),this.input(e,"to"),this.input(e,"duration"),Je(e,"curve")??"Linear"]);case"transform.moveTo":return new W("tweenMoveTo",this.transformTweenArgs(e,"position",!0));case"transform.moveBy":return new W("tweenMoveBy",this.transformTweenArgs(e,"offset",!0));case"transform.rotateTo":return new W("tweenRotateTo",this.transformTweenArgs(e,"rotation",!0));case"transform.rotateBy":return new W("tweenRotateBy",[this.input(e,"target"),this.input(e,"angle"),this.input(e,"duration"),Je(e,"curve")??"Linear",xe(e),Ae(e)]);case"transform.scaleTo":return new W("tweenScaleTo",this.transformTweenArgs(e,"scale",!1));case"transform.scaleBy":return new W("tweenScaleBy",this.transformTweenArgs(e,"factor",!1));case"actor.callMethod":{const t=this.callArguments(e);return new q(this.input(e,"target"),Oe(e,"method"),t,!0===e.params?.awaitResult)}case"actor.tryCallMethod":return new Y(this.input(e,"target"),Oe(e,"method"),this.callArguments(e),!0===e.params?.awaitResult);case"actor.findByType":return new B(this.input(e,"actorClass"));case"actor.findAllByType":return new z(this.input(e,"actorClass"));case"event.bindSource":{const t=this.dynamicEventSourceInfo(e);return new R(e.id,this.input(e,"target"),Oe(e,"source"),this.eventSourceRuntimeArguments(e,t),Je(e,"component"))}case"actor.spawnClass":return new Q(Oe(e,"classId"));case"actor.spawnPrefab":return new X(this.input(e,"prefab"),this.input(e,"position"),this.input(e,"rotation"));case"vfx.play":return new U(this.input(e,"vfx"),this.input(e,"position"),this.input(e,"rotation"),this.input(e,"autoDestroy"));case"sequence.play":return new G(this.input(e,"sequence"),this.input(e,"target"),this.input(e,"cameraControlEnabled"),this.input(e,"autoDestroy"));case"prefab.destroy":return new M(this.input(e,"instance"));case"actor.destroy":return new j(this.input(e,"actor"));default:throw new Error(`Node kind ${JSON.stringify(e.kind)} has no lowering implementation`)}}input(e,t){const n=this.document.getInput(e,t);if(null==n){const n=this.typeAnalysis.getInputType(e.id,t),r=ke(e)?Se(n):void 0;if(void 0!==r)return $e(n)?new _(r,n):r;throw new Error(`Node ${JSON.stringify(e.id)} is missing input ${JSON.stringify(t)}`)}if("value"in n){const r=this.typeAnalysis.getInputType(e.id,t);return $e(r)?new _(n.value,r):n.value}return this.output(n)}transformTweenArgs(e,t,n){return[this.input(e,"target"),this.input(e,t),this.input(e,"duration"),Je(e,"curve")??"Linear",...n?[xe(e)]:[]]}callArguments(e){const t=function(e,t){const n=e.params?.[t];if(null==n)return;if("number"!=typeof n)throw new Error(`Node ${JSON.stringify(e.id)} parameter ${JSON.stringify(t)} must be a number`);return n}(e,"argumentCount")??0;if(!Number.isInteger(t)||t<0)throw new Error(`Call Method node ${JSON.stringify(e.id)} has an invalid argumentCount`);return Array.from({length:t},(t,n)=>this.input(e,`arg${n}`))}dynamicEventSourceInfo(e){let t=this.connectedInputType(e,"target");return t=we(t,Je(e,"component"),Je(e,"componentTypeId")),he(t,Oe(e,"source"))}connectedInputType(e,t){const n=this.document.getInput(e,t);return null!=n&&"nodeId"in n?this.typeAnalysis.getOutputType(n.nodeId,n.port):this.typeAnalysis.getInputType(e.id,t)}eventSourceRuntimeArguments(e,t){let n=0;return t.parameters.map((t,r)=>"actorClass"===t.type.kind?{kind:"actorClass",classId:Oe(e,`arg${r}ActorClassId`)}:this.input(e,"arg"+n++))}output(e){const t=this.document.getNode(e.nodeId);if("data"!==Ne(t,e.port,"outputs").kind)throw new Error(`Socket ${JSON.stringify(Te(e))} is not a data output`);if(!0===u[t.kind].event){if(t.id!==this.eventNode.id)throw new Error(`Handler ${JSON.stringify(this.eventNode.id)} cannot read data from event ${JSON.stringify(t.id)}`);if(!function(e,t){return"event.update"===e.kind&&"deltaTime"===t||"event.observable"===e.kind&&"value"===t||"event.source"===e.kind&&"value"===t}(t,e.port))throw new Error(`Event node ${JSON.stringify(t.id)} has no data output ${JSON.stringify(e.port)}`);let n=this.eventValues.get(e.port);return null==n&&(n=new P,n.id=`${t.id}:${e.port}`,this.eventValues.set(e.port,n)),n}const n=this.lowerNode(t);return n instanceof s&&"value"===e.port?n:n.output(e.port)}}function pe(e,t){const n=Oe(e,"actorId"),r=t.resolveActorClass?.(n);return we(null!=r?{kind:"actor",classId:ge(r)}:{kind:"actor"},Je(e,"component"),Je(e,"componentTypeId"))}function he(e,t){const n=me(e),r=null!=n?ie(n,t):void 0;if(null==r)throw new Error(`Event source ${JSON.stringify(t)} is not exposed to event graphs`);return r}function fe(e,t){return t.parameters.map((n,r)=>{if("actorClass"===n.type.kind)return{kind:"actorClass",classId:Oe(e,`arg${r}ActorClassId`)};if("actor"===n.type.kind)return{kind:"actor",actorId:Oe(e,`arg${r}ActorId`)};throw new Error(`Static event source ${JSON.stringify(t.label)} parameter ${JSON.stringify(n.name)} must be an actor or actor class selector`)})}function we(e,t,n){if(null!=t){const n=function(e,t){const n=me(e);return null!=n?se(n,t):void 0}(e,t)?.type;if(null!=n)return n}return null!=n?{kind:"component",classId:n}:null!=t?{kind:"component"}:e}function me(n){return"actor"===n.kind&&null!=n.classId?e(n.classId):"component"===n.kind&&null!=n.classId?t(n.classId):void 0}function ge(e){return e.__actorId??e.name}function ye(e){const t=e.params?.ports;if(!Array.isArray(t)||0===t.length||t.some(e=>"string"!=typeof e||0===e.length))throw new Error(`${u[e.kind].label} node ${JSON.stringify(e.id)} requires non-empty string ports`);const n=t;if(n.includes("then"))throw new Error(`${u[e.kind].label} node reserves the "then" port for its continuation`);if(new Set(n).size!==n.length)throw new Error(`${u[e.kind].label} node branch names must be unique`);return n}function ve(e){const t=e.params?.cases;if(!Array.isArray(t)||0===t.length)throw new Error(`Switch node ${JSON.stringify(e.id)} requires at least one case`);const n=t.map(t=>{if(null==t||Array.isArray(t)||"object"!=typeof t)throw new Error(`Switch node ${JSON.stringify(e.id)} has an invalid case`);const n=t.port;if("string"!=typeof n||0===n.length||"then"===n||"default"===n)throw new Error(`Switch node ${JSON.stringify(e.id)} has an invalid case port`);if(!Object.prototype.hasOwnProperty.call(t,"value"))throw new Error(`Switch node ${JSON.stringify(e.id)} case ${JSON.stringify(n)} is missing a value`);return{match:be(t.value),port:n}});if(new Set(n.map(e=>e.port)).size!==n.length)throw new Error(`Switch node ${JSON.stringify(e.id)} case ports must be unique`);if(new Set(n.map(e=>e.match)).size!==n.length)throw new Error(`Switch node ${JSON.stringify(e.id)} case values must be unique`);return n}function Ne(e,t,n){const r=l(e,t,n);if(null!=r)return r;throw new Error(`Node ${JSON.stringify(e.id)} has no ${n.slice(0,-1)} port ${JSON.stringify(t)}`)}function Ee(e){const t=e.params?.value;if("constant.vector2"===e.kind||"constant.vector3"===e.kind){const n="constant.vector2"===e.kind?{kind:"vector2"}:{kind:"vector3"};if(!p(t,n))throw new Error(`Node ${JSON.stringify(e.id)} requires a finite ${n.kind} tuple`);return t}const n="constant.boolean"===e.kind?"boolean":"constant.number"===e.kind?"number":"string";if(typeof t!==n)throw new Error(`Node ${JSON.stringify(e.id)} requires a ${n} value`);if("number"==typeof t&&!Number.isFinite(t))throw new Error("Event graph numbers must be finite");return t}function $e(e){return"vector2"===e.kind||"vector3"===e.kind||"euler"===e.kind||"asset"===e.kind||"actorClass"===e.kind||"optional"===e.kind&&$e(e.value)||"array"===e.kind&&$e(e.element)}function ke(e){return"compare.equal"===e.kind||"compare.notEqual"===e.kind}function Se(e){return"boolean"!==e.kind&&("number"===e.kind?0:"string"===e.kind?"":"vector2"===e.kind?[0,0]:"vector3"===e.kind||"euler"===e.kind?[0,0,0]:void 0)}function be(e){if("number"==typeof e&&!Number.isFinite(e))throw new Error("Event graph numbers must be finite");const t=JSON.stringify(e);if(null==t)throw new Error("Event graph value cannot be serialized to JavaScript");return t}function Ie(e,t){const n=Oe(e,"variable");if(!t.has(n))throw new Error(`Node ${JSON.stringify(e.id)} references undeclared variable ${JSON.stringify(n)}`);return n}function Oe(e,t){const n=e.params?.[t];if("string"!=typeof n||0===n.length)throw new Error(`Node ${JSON.stringify(e.id)} requires a non-empty string parameter ${JSON.stringify(t)}`);return n}function Je(e,t){const n=e.params?.[t];if(null!=n&&""!==n){if("string"!=typeof n)throw new Error(`Node ${JSON.stringify(e.id)} parameter ${JSON.stringify(t)} must be a string`);return n}}function xe(e){const t=Je(e,"space")??"local";if("local"!==t&&"world"!==t)throw new Error(`Node ${JSON.stringify(e.id)} has invalid transform space ${JSON.stringify(t)}`);return t}function Ae(e){const t=Je(e,"axis")??"y";if("x"!==t&&"y"!==t&&"z"!==t)throw new Error(`Node ${JSON.stringify(e.id)} has invalid rotation axis ${JSON.stringify(t)}`);return t}function Te(e){return`${e.nodeId}:${e.port}`}function qe(e){return`${Te(e.from)} -> ${Te(e.to)}`}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-graph-demo.d.ts.map

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

@@ -0,0 +1,4 @@
+import{AssignNode as e,BranchNode as n,CallScopeNode as o,ConstantNumberNode as t,DelayNode as c,LogNode as s,ParallelNode as w,ParseNumberNode as l,SplitStringNode as r,StartNode as a,ThisNode as h,VariableNode as i}from"./nodes/index.js";import{Compiler as d}from"./compiler.js";const m=Object.getPrototypeOf(async function(){}).constructor,p=new d;{const d=new a,u=new t(1).add(2),f=new s(u),g=new s(new h),b=new e("assignTest",u.asString().add(" hi")),y=new s(new i("assignTest")),j=new c(1e3),O=new o,T=new w("slow","fast"),P=new c(30),v=new c(5),x=new s("both parallel branches completed"),C=new n(!0),D=new s("branch completed"),F=new l("not a number"),S=new r("hello:world",":"),k=new s(S.before),q=new s(S.after);d.then(f),f.then(g),g.then(b),b.then(y),y.then(j),j.then(O),O.then(T),T.connect("slow",P),P.then(new s("slow branch completed")),T.connect("fast",v),v.then(new s("fast branch completed")).then(q),T.then(x),x.then(C),C.connect("true",F),C.connect("false",new s("condition was false")),C.then(D),D.then(k),k.then(q),F.connect("success",new s(F.value));const z=new s(F.error);F.connect("error",z);const A=p.compile(d);console.log("----- Code -----"),console.log(A.source),console.log("----- Output -----");const B=new(A.async?m:Function)("runtime",A.source);await B.apply({foo:()=>console.log("passed function")},[{delay:e=>new Promise(n=>setTimeout(n,e))}]),console.log("----- Done ------")}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

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

@@ -0,0 +1,106 @@
+import type { CompilationContext } from './compiler.js';
+export type ValueLiteral = string | number | boolean | null | ValueLiteral[] | {
+    [key: string]: ValueLiteral;
+};
+export type DataCompileResult = {
+    /** Setup emitted once before this node's outputs are first used in a block. */
+    setup?: string;
+    outputs: Readonly<Record<string, string>>;
+};
+export type ExecutionRoute = {
+    kind: 'branch';
+    condition: string;
+    truePort: string;
+    falsePort: string;
+    continuationPort?: string;
+} | {
+    kind: 'select';
+    expression: string;
+    cases: ReadonlyArray<{
+        match: string;
+        port: string;
+    }>;
+    defaultPort?: string;
+    continuationPort?: string;
+} | {
+    kind: 'parallel';
+    ports: ReadonlyArray<string>;
+    continuationPort: string;
+} | {
+    kind: 'sequence';
+    ports: ReadonlyArray<string>;
+    continuationPort: string;
+} | {
+    kind: 'forLoop';
+    firstIndexExpression: string;
+    lastIndexExpression: string;
+    indexOutput: string;
+    bodyPort: string;
+    continuationPort: string;
+} | {
+    kind: 'forEach';
+    arrayExpression: string;
+    elementOutput: string;
+    indexOutput: string;
+    bodyPort: string;
+    continuationPort: string;
+} | {
+    kind: 'try';
+    attempt: string;
+    catchVariable: string;
+    recover?: string;
+    successPort: string;
+    errorPort: string;
+    continuationPort?: string;
+} | {
+    kind: 'completion';
+    actorExpression: string;
+    completedPort: string;
+    continuationPort: string;
+} | {
+    kind: 'runtimeCallback';
+    callee: string;
+    arguments: readonly string[];
+    completedPort: string;
+    continuationPort: string;
+    callbackValueOutput?: string;
+    returnValueOutput?: string;
+};
+export type ExecutionCompileResult = {
+    /** Code executed when control reaches the node. */
+    chunk?: string;
+    /** A promise that must settle before routing to the next node. */
+    done?: string;
+    /** Structured control flow that chooses a named execution output. */
+    route?: ExecutionRoute;
+    /** The node changes values that cached pure computations may depend on. */
+    invalidatesValues?: boolean;
+    /** The emitted chunk contains await and requires an async handler. */
+    requiresAsync?: boolean;
+};
+export declare class DataOutput<T = unknown> {
+    readonly node: Node;
+    readonly name: string;
+    readonly type: T;
+    constructor(node: Node, name: string);
+}
+export type ValueInput<T = unknown> = ValueLiteral | PureNode | DataOutput<T>;
+export declare abstract class Node {
+    /** Used by editor integrations, breakpoints, and profiling. */
+    id?: string;
+    private readonly dataOutputs;
+    output<T = unknown>(name?: string): DataOutput<T>;
+}
+/** A side-effect-free node whose outputs may inline or share block-local setup. */
+export declare abstract class PureNode extends Node {
+    abstract compileData(c: CompilationContext): DataCompileResult;
+}
+/** A node reached through execution pins and emitted as a basic block. */
+export declare abstract class ExecutionNode extends Node {
+    private readonly executionOutputs;
+    connect(output: string, downstream: ExecutionNode): ExecutionNode;
+    then(downstream: ExecutionNode): ExecutionNode;
+    getExecutionOutputs(): ReadonlyMap<string, ExecutionNode>;
+    abstract compileExecution(c: CompilationContext): ExecutionCompileResult;
+}
+//# sourceMappingURL=graph.d.ts.map

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.
+ */