@hology/core 0.0.211 → 0.0.213

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

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

@@ -0,0 +1,21 @@
+import { Euler, Vector3 } from 'three';
+import { PrefabInstance } from '../../scene/objects/prefab.js';
+import { BaseActor } from '../actors/actor.js';
+import type { AssetsProvider } from '../../scene/assets-provider.js';
+import type { World } from '../services/world.js';
+import type { EventGraphAssetRuntime, EventGraphTransientAssetHandle } from './runtime.js';
+export declare class WorldEventGraphAssetRuntime implements EventGraphAssetRuntime {
+    private readonly world;
+    private readonly assets;
+    constructor(world: World, assets: AssetsProvider);
+    spawnPrefab(assetId: string, position: Vector3, rotation: Euler): Promise<{
+        instance: PrefabInstance;
+        mainActor: BaseActor | null;
+    }>;
+    playVfx(assetId: string, position: Vector3, rotation: Euler): Promise<EventGraphTransientAssetHandle>;
+    playSequence(assetId: string, self: BaseActor | null, target: BaseActor | null, cameraControlEnabled: boolean): Promise<EventGraphTransientAssetHandle>;
+    destroyPrefab(instance: unknown): void;
+    destroyActor(actor: unknown): void;
+    private requireAsset;
+}
+//# sourceMappingURL=runtime-assets.d.ts.map

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

@@ -0,0 +1,4 @@
+import{Prefab as e,PrefabInstance as t}from"../../scene/objects/prefab.js";import{BaseActor as r}from"../actors/actor.js";export class WorldEventGraphAssetRuntime{constructor(e,t){this.world=e,this.assets=t}async spawnPrefab(t,r,s){const a=await this.requireAsset(t,"prefab"),o=await this.world.spawnPrefab(new e(a),r,s);if(null==o)throw new Error(`Failed to spawn prefab asset ${JSON.stringify(t)}`);return{instance:o,mainActor:o.mainActor}}async playVfx(e,t,r){const s=await this.requireAsset(e,"vfx"),{VfxActor:a}=await import("../../effects/vfx/vfx-actor.js"),o=await this.world.spawnActor(a,t,r);try{return await o.fromAsset(s),o.play(),{actor:o,completed:o.onComplete}}catch(e){throw this.destroyActor(o),e}}async playSequence(e,t,r,s){const a=await this.requireAsset(e,"sequence"),[{SequenceActor:o},{SequenceRole:n}]=await Promise.all([import("../../effects/sequence/sequence-actor.js"),import("../../effects/sequence/sequence-data.js")]),i=await this.world.spawnActor(o);try{return await i.loadFromAsset(a),null!=t&&i.bindRole(n.Self,t),null!=r&&i.bindRole(n.Target,r),i.play({cameraControlEnabled:s}),{actor:i,completed:i.onComplete}}catch(e){throw this.destroyActor(i),e}}destroyPrefab(e){if(!(e instanceof t))throw new Error("Event graph prefab handle is invalid");this.world.removePrefab(e)}destroyActor(e){if(!(e instanceof r))throw new Error("Event graph actor handle is invalid");this.world.actors.includes(e)&&this.world.removeActor(e)}async requireAsset(e,t){const r=await this.assets.getAsset(e);if(null==r)throw new Error(`Event graph could not resolve asset ${JSON.stringify(e)}`);if(r.type!==t)throw new Error(`Event graph expected ${t} asset ${JSON.stringify(e)}, received ${r.type}`);return r}}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

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

@@ -0,0 +1,160 @@
+import { type Observable } from 'rxjs';
+import { Euler, Vector2, Vector3 } from 'three';
+import type { Type } from '../../utils/type.js';
+import { BaseActor } from '../actors/actor.js';
+import { ActorComponent } from '../actors/component.js';
+import type { EventGraphDocument, EventGraphTransformAxis, EventGraphTransformSpace } from './model.js';
+import { EventGraphCompiler, type EventGraphExecutionContext } from './document-compiler.js';
+export interface EventGraphWorld {
+    spawnActor(type: new (...args: any[]) => BaseActor): Promise<BaseActor>;
+    findActorByType?(type: Type<BaseActor>): BaseActor | undefined;
+    findActorsByType?(type: Type<BaseActor>): BaseActor[];
+}
+export interface EventGraphTransientAssetHandle {
+    actor: unknown;
+    completed?: Observable<unknown>;
+}
+export interface EventGraphAssetRuntime {
+    spawnPrefab(assetId: string, position: Vector3, rotation: Euler): Promise<{
+        instance: unknown;
+        mainActor: unknown | null;
+    }>;
+    playVfx(assetId: string, position: Vector3, rotation: Euler): Promise<EventGraphTransientAssetHandle>;
+    playSequence(assetId: string, self: BaseActor | null, target: BaseActor | null, cameraControlEnabled: boolean): Promise<EventGraphTransientAssetHandle>;
+    destroyPrefab(instance: unknown): void;
+    destroyActor(actor: unknown): void;
+}
+export interface EventGraphInstanceOptions {
+    world: EventGraphWorld;
+    assets?: EventGraphAssetRuntime;
+    actorsById: ReadonlyMap<string, BaseActor>;
+    mainActor?: BaseActor | null;
+    updates?: Observable<number>;
+    timer?: {
+        setInterval(callback: () => void, intervalMs: number, owner?: BaseActor): number;
+        clearInterval(intervalId: number): void;
+        createTimer?(durationMs: number): Observable<void>;
+    };
+    physics?: {
+        updateActorTransform(actor: BaseActor): void;
+    };
+    onError?: (error: unknown, eventNodeId: string) => void;
+}
+/** Owns the compiled handlers, state, and subscriptions for one spawned prefab. */
+export declare class EventGraphInstance implements EventGraphExecutionContext {
+    private readonly options;
+    private readonly compiled;
+    private readonly subscriptions;
+    private readonly variables;
+    private readonly variableTypes;
+    private readonly pendingDelays;
+    private readonly pendingTweens;
+    private readonly completedTweens;
+    private readonly tweensByTarget;
+    private readonly transientActors;
+    private readonly dynamicEventSourceSubscriptions;
+    private readonly intervals;
+    private readonly doOnceStates;
+    private readonly gateStates;
+    private readonly vector2Pool;
+    private readonly vector3Pool;
+    private readonly eulerPool;
+    private vector2PoolIndex;
+    private vector3PoolIndex;
+    private eulerPoolIndex;
+    private updateSubscription?;
+    private started;
+    private ended;
+    constructor(graph: EventGraphDocument, options: EventGraphInstanceOptions, compiler?: EventGraphCompiler);
+    beginPlay(): Promise<void>;
+    endPlay(): void;
+    actor(id: string): BaseActor;
+    component(target: unknown, property: string): ActorComponent;
+    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): Type<BaseActor>;
+    findActorByType(actorClass: unknown): BaseActor | undefined;
+    findActorsByType(actorClass: unknown): BaseActor[];
+    bindEventSource(nodeId: string, target: unknown, method: string, args: unknown[], callback: ((value: unknown) => unknown) | undefined, eventNodeId: string): void;
+    spawnActor(classId: string): Promise<BaseActor>;
+    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;
+    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>;
+    destroyPrefab(instance: unknown): void;
+    destroyActor(actor: unknown): void;
+    onActorCompleted(actor: unknown, callback: () => unknown, eventNodeId: string): void;
+    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;
+    private beginValueScope;
+    private invokeHandler;
+    private invokeCallback;
+    private createScopedEuler;
+    private mathBinary;
+    private mathVector2;
+    private mathVector3;
+    private setActorTransformProperty;
+    private createMoveTween;
+    private startTween;
+    private ensureUpdateSubscription;
+    private tickTweens;
+    private applyTween;
+    private applyTweenRotation;
+    private finishTween;
+    private cancelTween;
+    private cancelTweens;
+    private releaseUpdateSubscriptionIfIdle;
+    private requireAssets;
+    private requireAssetId;
+    private retainTransientHandle;
+    private releaseTransientActor;
+    private destroyTransientActors;
+    private subscribeObservable;
+    private subscribeEventSource;
+    private createEventSourceObservable;
+    private resolveEventSourceArgument;
+    private dispatch;
+    private assertExposedProperty;
+    private writableExposedPropertyInfo;
+    private assertObject;
+    private unsubscribeAll;
+    private replaceDynamicEventSourceSubscription;
+    private removeSubscription;
+    private cancelDelays;
+    private clearIntervals;
+    private reportError;
+}
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1,4 @@
+import{isObservable as e,take as t}from"rxjs";import{Euler as r,MathUtils as n,Quaternion as o,Vector2 as s,Vector3 as i}from"three";import{Curve2 as a}from"../../utils/curve.js";import{BaseActor as c,getActorClassById as l}from"../actors/actor.js";import{ActorComponent as u}from"../actors/component.js";import{inferEventGraphLiteralType as h,isTweenableEventGraphType as p}from"./types.js";import{EventGraphCompiler as d}from"./document-compiler.js";import{isEventGraphEventSource as f,getEventGraphPropertyInfo as w,isEventGraphCallable as y,isEventGraphProperty as v}from"./decorators.js";import{getEventGraphActorTransformPropertyInfo as m,isEventGraphActorTransformProperty as b}from"./actor-transform-properties.js";export class EventGraphInstance{constructor(e,t,r=new d){this.options=t,this.subscriptions=[],this.variables=new Map,this.variableTypes=new Map,this.pendingDelays=new Set,this.pendingTweens=new Set,this.completedTweens=[],this.tweensByTarget=new WeakMap,this.transientActors=new Map,this.dynamicEventSourceSubscriptions=new Map,this.intervals=new Map,this.doOnceStates=new Map,this.gateStates=new Map,this.vector2Pool=[],this.vector3Pool=[],this.eulerPool=[],this.vector2PoolIndex=0,this.vector3PoolIndex=0,this.eulerPoolIndex=0,this.started=!1,this.ended=!1,this.compiled=r.compile(e,{resolveActorClass:e=>{const r="$self"===e?t.mainActor:t.actorsById.get(e);return r?.constructor}});for(const t of e.variables??[]){const e=t.type??h(t.defaultValue);this.variableTypes.set(t.name,e),this.variables.set(t.name,g(t.defaultValue,e))}}async beginPlay(){if(!this.started){if(this.ended)throw new Error("Cannot begin play for an event graph that has ended");this.started=!0;try{for(const e of this.compiled.observables)this.subscriptions.push(this.subscribeObservable(e));for(const e of this.compiled.eventSources)this.subscriptions.push(this.subscribeEventSource(e));for(const e of this.compiled.beginPlay)await this.invokeHandler(e);!this.ended&&this.compiled.update.length>0&&this.ensureUpdateSubscription()}catch(e){throw this.unsubscribeAll(),this.clearIntervals(),this.cancelDelays(),this.cancelTweens(),this.destroyTransientActors(),this.ended=!0,e}}}endPlay(){this.ended||(this.ended=!0,this.unsubscribeAll(),this.clearIntervals(),this.cancelDelays(),this.cancelTweens(),this.dispatch(this.compiled.endPlay),this.destroyTransientActors())}actor(e){const t="$self"===e?this.options.mainActor:this.options.actorsById.get(e);if(null==t)throw new Error(`Event graph could not resolve prefab actor ${JSON.stringify(e)}`);return t}component(e,t){if(this.assertObject(e,"component target"),!(e instanceof c))throw new Error("Event graph component target must be an actor");const r=e[t];if(!(r instanceof u))throw new Error(`Actor property ${JSON.stringify(t)} is not an actor component`);return r}getProperty(e,t){return e instanceof c&&b(t)?e.object[t]:(this.assertExposedProperty(e,t),e[t])}setProperty(e,t,r){if(e instanceof c&&b(t))return void this.setActorTransformProperty(e,t,r);const n=this.writableExposedPropertyInfo(e,t);e[t]=E(r,n.type,e[t])}tweenProperty(e,t,r,n,s,i,a){if(this.ended)return;const c=q(e),l=m(t)??w(c,t);if(null==l)throw new Error(`Property ${JSON.stringify(t)} is not marked with @EventGraphProperty`);if(!l.writable)throw new Error(`Property ${JSON.stringify(t)} is read-only`);if(!p(l.type))throw new Error(`Property ${JSON.stringify(t)} cannot be tweened`);const u=j(this.getProperty(c,t),l,"current"),h=j(r,l,"to"),d={kind:"property",target:c,property:t,type:l.type,from:u,to:h,value:(f=u,"number"==typeof f?f:f.clone()),...N(n,s,i,a)};var f;"euler"===l.type.kind&&(d.fromQuaternion=(new o).setFromEuler(u),d.toQuaternion=(new o).setFromEuler(h),d.quaternion=new o),this.startTween(d)}tweenMoveTo(e,t,r,n,o,s,i){this.ended||this.startTween(this.createMoveTween(e,$(t,"Move To position"),r,n,o,!1,s,i))}tweenMoveBy(e,t,r,n,o,s,i){this.ended||this.startTween(this.createMoveTween(e,$(t,"Move By offset"),r,n,o,!0,s,i))}tweenRotateTo(e,t,r,n,s,i,a){if(this.ended)return;const c=q(e);if(B(s),!T(t))throw new Error("Rotate To rotation must be a Three.js Euler");const l="world"===s?c.object.getWorldQuaternion(new o):c.object.quaternion.clone();this.startTween({kind:"rotateTo",target:c,property:"rotation",space:s,from:l,to:(new o).setFromEuler(t),value:new o,parentQuaternion:new o,localQuaternion:new o,...N(r,n,i,a)})}tweenRotateBy(e,t,r,s,i,a,c,l){if(this.ended)return;const u=q(e);if(B(i),!Number.isFinite(t))throw new Error("Rotate By angle must be a finite number");const h="world"===i?u.object.getWorldQuaternion(new o):u.object.quaternion.clone();this.startTween({kind:"rotateBy",target:u,property:"rotation",space:i,from:h,axis:M(a),angle:n.degToRad(t),delta:new o,value:new o,parentQuaternion:new o,localQuaternion:new o,...N(r,s,c,l)})}tweenScaleTo(e,t,r,n,o,s){if(this.ended)return;const a=q(e);this.startTween({kind:"scale",target:a,property:"scale",from:a.object.scale.clone(),to:$(t,"Scale To value").clone(),value:new i,...N(r,n,o,s)})}tweenScaleBy(e,t,r,n,o,s){if(this.ended)return;const a=q(e),c=a.object.scale.clone();this.startTween({kind:"scale",target:a,property:"scale",from:c,to:c.clone().multiply($(t,"Scale By factor")),value:new i,...N(r,n,o,s)})}callMethod(e,t,r){if(this.assertObject(e,"method target"),!y(e,t))throw new Error(`Method ${JSON.stringify(t)} is not marked with @EventGraphCallable`);const n=e[t];if("function"!=typeof n)throw new Error(`Event graph target has no method ${JSON.stringify(t)}`);return n.apply(e,r)}actorClass(e){const t=l(e);if(null==t)throw new Error(`Event graph could not resolve actor class ${JSON.stringify(e)}`);return t}findActorByType(e){const t=this.options.world.findActorByType;if(null==t)throw new Error("Event graph world does not support finding actors by type");return t.call(this.options.world,S(e))}findActorsByType(e){const t=this.options.world.findActorsByType;if(null==t)throw new Error("Event graph world does not support finding actors by type");return t.call(this.options.world,S(e))}bindEventSource(e,t,r,n,o,s){if(this.ended)return;this.replaceDynamicEventSourceSubscription(e,void 0);const i=this.createEventSourceObservable(t,r,n).subscribe(e=>{null==o||this.ended||this.invokeCallback(()=>o(e),s)});this.replaceDynamicEventSourceSubscription(e,i)}async spawnActor(e){const t=l(e);if(null==t)throw new Error(`Event graph could not resolve actor class ${JSON.stringify(e)}`);return this.options.world.spawnActor(t)}getVariable(e){if(!this.variables.has(e))throw new Error(`Event graph variable ${JSON.stringify(e)} is not declared`);return this.variables.get(e)}setVariable(e,t){if(!this.variables.has(e))throw new Error(`Event graph variable ${JSON.stringify(e)} is not declared`);this.variables.set(e,E(t,this.variableTypes.get(e),this.variables.get(e)))}delay(e){if(this.ended)return Promise.reject(new D);if(!Number.isFinite(e)||e<0)return Promise.reject(new Error("Event graph delay must be a finite non-negative number"));const t=this.options.timer;return null==t?.createTimer?Promise.reject(new Error("Event graph delay requires a game-time timer")):new Promise((r,n)=>{const o={subscription:void 0,reject:n};o.subscription=t.createTimer(e).subscribe({next:()=>{this.pendingDelays.delete(o),r()},error:e=>{this.pendingDelays.delete(o),n(e)}}),o.subscription.closed?this.pendingDelays.delete(o):this.pendingDelays.add(o)})}setInterval(e,t,r,n){if(this.ended)return;if(!Number.isFinite(t)||t<=0)throw new Error("Event graph interval must be a finite number greater than zero");const o=this.options.timer;if(null==o)throw new Error("Event graph interval requires a game-time timer");const s=this.intervals.get(e);if(null!=s&&o.clearInterval(s),this.intervals.delete(e),null==r){const r=o.setInterval(()=>{},t,this.options.mainActor??void 0);return this.intervals.set(e,r),r}const i=o.setInterval(()=>{this.ended||this.invokeCallback(r,n)},t,this.options.mainActor??void 0);return this.intervals.set(e,i),i}clearInterval(e){if(!Number.isSafeInteger(e))throw new Error("Event graph timer must be a valid timer id");this.options.timer?.clearInterval(e);for(const[t,r]of this.intervals)if(r===e){this.intervals.delete(t);break}}doOnce(e,t,r){if("reset"===t)return this.doOnceStates.set(e,!1),!1;if("exec"!==t)throw new Error(`Unsupported Do Once input ${JSON.stringify(t)}`);return!(this.doOnceStates.get(e)??r)&&(this.doOnceStates.set(e,!0),!0)}gate(e,t,r){let n=this.gateStates.get(e)??!r;if("open"===t)n=!0;else if("close"===t)n=!1;else if("toggle"===t)n=!n;else if("enter"!==t)throw new Error(`Unsupported Gate input ${JSON.stringify(t)}`);return this.gateStates.set(e,n),"enter"===t&&n}async spawnPrefab(e,t,r){const n=this.requireAssets(),o=$(t,"Spawn Prefab position").clone(),s=J(r,"Spawn Prefab rotation").clone(),i=await n.spawnPrefab(this.requireAssetId(e),o,s);if(this.ended)throw n.destroyPrefab(i.instance),new D;return i}async playVfx(e,t,r,n){const o=this.requireAssets(),s=$(t,"Play VFX position").clone(),i=J(r,"Play VFX rotation").clone(),a=await o.playVfx(this.requireAssetId(e),s,i);return this.retainTransientHandle(o,a,n)}async playSequence(e,t,r,n){if(null!=t&&!(t instanceof c))throw new Error("Event graph sequence target must be an actor");const o=this.requireAssets(),s=await o.playSequence(this.requireAssetId(e),this.options.mainActor??null,t,r);return this.retainTransientHandle(o,s,n)}destroyPrefab(e){this.requireAssets().destroyPrefab(e)}destroyActor(e){const t=this.requireAssets();this.releaseTransientActor(t,e)}onActorCompleted(e,r,n){const o=this.transientActors.get(e)?.completed;if(null==o)throw new Error("Event graph actor does not expose a completion signal");const s=o.pipe(t(1)).subscribe(()=>{this.invokeCallback(r,n)});this.subscriptions.push(s)}readValue(e){return A(e)?this.createVector2(e.x,e.y):P(e)?this.createVector3(e.x,e.y,e.z):T(e)?this.createScopedEuler(e.x,e.y,e.z,e.order):e}mathAdd(e,t){return this.mathBinary(e,t,"add")}mathSubtract(e,t){return this.mathBinary(e,t,"subtract")}mathMultiply(e,t){return this.mathBinary(e,t,"multiply")}mathDivide(e,t){return this.mathBinary(e,t,"divide")}mathModulo(e,t){return this.mathBinary(e,t,"modulo")}vectorLength(e){if(A(e)||P(e))return e.length();throw new Error("Event graph Vector Length requires a Vector2 or Vector3")}vectorLengthSquared(e){if(A(e)||P(e))return e.lengthSq();throw new Error("Event graph Vector Length Squared requires a Vector2 or Vector3")}vectorDistance(e,t){if(A(e)&&A(t)||P(e)&&P(t))return e.distanceTo(t);throw new Error("Event graph Vector Distance requires matching Vector2 or Vector3 values")}vectorDistanceSquared(e,t){if(A(e)&&A(t)||P(e)&&P(t))return e.distanceToSquared(t);throw new Error("Event graph Vector Distance Squared requires matching Vector2 or Vector3 values")}vectorNormalize(e){if(A(e))return this.createVector2(e.x,e.y).normalize();if(P(e))return this.createVector3(e.x,e.y,e.z).normalize();throw new Error("Event graph Vector Normalize requires a Vector2 or Vector3")}vectorDot(e,t){if(A(e)&&A(t)||P(e)&&P(t))return e.dot(t);throw new Error("Event graph Dot Product requires matching Vector2 or Vector3 values")}vectorCross(e,t){if(!P(e)||!P(t))throw new Error("Event graph Cross Product requires Vector3 values");return this.createVector3(e.x,e.y,e.z).cross(t)}vectorLerp(e,t,r){if(!Number.isFinite(r))throw new Error("Event graph Vector Lerp alpha must be a finite number");if(A(e)&&A(t))return this.createVector2(e.x,e.y).lerp(t,r);if(P(e)&&P(t))return this.createVector3(e.x,e.y,e.z).lerp(t,r);throw new Error("Event graph Vector Lerp requires matching Vector2 or Vector3 values")}vectorApplyRotation(e,t){if(!P(e))throw new Error("Event graph Apply Rotation value must be a Vector3");return this.createVector3(e.x,e.y,e.z).applyEuler(J(t,"Apply Rotation rotation"))}createVector2(e,t){let r=this.vector2Pool[this.vector2PoolIndex];return null==r&&(r=new s,this.vector2Pool[this.vector2PoolIndex]=r),this.vector2PoolIndex++,r.set(e,t)}createVector3(e,t,r){let n=this.vector3Pool[this.vector3PoolIndex];return null==n&&(n=new i,this.vector3Pool[this.vector3PoolIndex]=n),this.vector3PoolIndex++,n.set(e,t,r)}createEuler(e,t,r){return this.createScopedEuler(e,t,r,"XYZ")}beginValueScope(){this.vector2PoolIndex=0,this.vector3PoolIndex=0,this.eulerPoolIndex=0}invokeHandler(e,t){return this.beginValueScope(),e.invoke(this,t)}invokeCallback(e,t){try{this.beginValueScope();const r=e();Q(r)&&r.catch(e=>this.reportError(e,t))}catch(e){this.reportError(e,t)}}createScopedEuler(e,t,n,o){let s=this.eulerPool[this.eulerPoolIndex];return null==s&&(s=new r,this.eulerPool[this.eulerPoolIndex]=s),this.eulerPoolIndex++,s.set(e,t,n,o)}mathBinary(e,t,r){if("number"==typeof e&&"number"==typeof t)return O(e,t,r);if(A(e)||A(t))return this.mathVector2(e,t,r);if(P(e)||P(t))return this.mathVector3(e,t,r);throw new Error(`Event graph ${r} requires numbers, Vector2, or Vector3 values`)}mathVector2(e,t,r){if(!V(e)||!V(t))throw new Error(`Event graph ${r} requires numbers or Vector2 values`);return this.createVector2(O(x(e,"x"),x(t,"x"),r),O(x(e,"y"),x(t,"y"),r))}mathVector3(e,t,r){if(!k(e)||!k(t))throw new Error(`Event graph ${r} requires numbers or Vector3 values`);return this.createVector3(O(I(e,"x"),I(t,"x"),r),O(I(e,"y"),I(t,"y"),r),O(I(e,"z"),I(t,"z"),r))}setActorTransformProperty(e,t,r){if("rotation"===t){if(!T(r))throw new Error("Event graph actor rotation must be a Three.js Euler");return e.object.rotation.copy(r),void this.options.physics?.updateActorTransform(e)}if(!P(r))throw new Error(`Event graph actor ${t} must be a Three.js Vector3`);e.object[t].copy(r),"position"===t&&this.options.physics?.updateActorTransform(e)}createMoveTween(e,t,r,n,o,s,a,c){const l=q(e);B(o);const u="world"===o?l.object.getWorldPosition(new i):l.object.position.clone();return{kind:"move",target:l,property:"position",space:o,from:u,to:s?u.clone().add(t):t.clone(),value:new i,localValue:new i,...N(r,n,a,c)}}startTween(e){this.cancelTween(e.target,e.property);let t=this.tweensByTarget.get(e.target);if(null==t&&(t=new Map,this.tweensByTarget.set(e.target,t)),t.set(e.property,e),this.pendingTweens.add(e),0===e.duration)return this.applyTween(e,1),void queueMicrotask(()=>{!this.ended&&this.pendingTweens.has(e)&&this.finishTween(e)});this.ensureUpdateSubscription(),this.applyTween(e,0)}ensureUpdateSubscription(){if(null==this.updateSubscription){if(null==this.options.updates)throw new Error("Event graph frame updates are required for Update events and property tweens");this.updateSubscription=this.options.updates.subscribe(e=>{this.tickTweens(e),this.dispatch(this.compiled.update,e)}),this.subscriptions.push(this.updateSubscription)}}tickTweens(e){if(Number.isFinite(e)&&!(e<0)){this.completedTweens.length=0;for(const t of this.pendingTweens){t.elapsed=Math.min(t.elapsed+e,t.duration);const r=t.elapsed/t.duration;this.applyTween(t,r>=1?1:t.curve.getY(r)),r>=1&&this.completedTweens.push(t)}for(const e of this.completedTweens)this.finishTween(e);this.completedTweens.length=0}}applyTween(e,t){if("property"===e.kind){let r;if("number"===e.type.kind)r=e.from+(e.to-e.from)*t;else if("vector2"===e.type.kind)r=e.value.lerpVectors(e.from,e.to,t);else if("vector3"===e.type.kind)r=e.value.lerpVectors(e.from,e.to,t);else{const n=e.quaternion.slerpQuaternions(e.fromQuaternion,e.toQuaternion,t);r=e.value.setFromQuaternion(n,e.from.order)}return void this.setProperty(e.target,e.property,r)}if("move"===e.kind){e.value.lerpVectors(e.from,e.to,t);const r="world"===e.space&&null!=e.target.object.parent?e.target.object.parent.worldToLocal(e.localValue.copy(e.value)):e.value;return e.target.object.position.copy(r),void this.options.physics?.updateActorTransform(e.target)}"scale"!==e.kind?("rotateTo"===e.kind?e.value.slerpQuaternions(e.from,e.to,t):"local"===e.space?(e.delta.setFromAxisAngle(e.axis,e.angle*t),e.value.multiplyQuaternions(e.from,e.delta)):(e.delta.setFromAxisAngle(e.axis,e.angle*t),e.value.multiplyQuaternions(e.delta,e.from)),this.applyTweenRotation(e,e.value)):e.target.object.scale.copy(e.value.lerpVectors(e.from,e.to,t))}applyTweenRotation(e,t){const r="world"===e.space&&null!=e.target.object.parent?e.localQuaternion.multiplyQuaternions(e.target.object.parent.getWorldQuaternion(e.parentQuaternion).invert(),t):t;e.target.object.quaternion.copy(r),this.options.physics?.updateActorTransform(e.target)}finishTween(e){this.pendingTweens.delete(e)&&(this.tweensByTarget.get(e.target)?.delete(e.property),null==e.completed||this.ended||this.invokeCallback(e.completed,e.eventNodeId),this.releaseUpdateSubscriptionIfIdle())}cancelTween(e,t){const r=this.tweensByTarget.get(e)?.get(t);null!=r&&(this.pendingTweens.delete(r),this.tweensByTarget.get(e)?.delete(t))}cancelTweens(){for(const e of this.pendingTweens)this.tweensByTarget.get(e.target)?.delete(e.property);this.pendingTweens.clear(),this.completedTweens.length=0}releaseUpdateSubscriptionIfIdle(){const e=this.updateSubscription;if(null==e||this.compiled.update.length>0||this.pendingTweens.size>0)return;e.unsubscribe();const t=this.subscriptions.indexOf(e);t>=0&&this.subscriptions.splice(t,1),this.updateSubscription=void 0}requireAssets(){if(null==this.options.assets)throw new Error("Event graph asset runtime is not configured");return this.options.assets}requireAssetId(e){if("string"!=typeof e||0===e.length)throw new Error("Event graph asset reference is missing");return e}retainTransientHandle(e,t,r){if(this.ended)throw e.destroyActor(t.actor),new D;const n=r?t.completed?.subscribe(()=>queueMicrotask(()=>{this.transientActors.has(t.actor)&&this.releaseTransientActor(e,t.actor)})):void 0;return this.transientActors.set(t.actor,{completed:t.completed,autoDestroySubscription:n}),t.actor}releaseTransientActor(e,t){const r=this.transientActors.get(t);r?.autoDestroySubscription?.unsubscribe(),this.transientActors.delete(t),e.destroyActor(t)}destroyTransientActors(){const e=this.options.assets;if(null!=e)for(const t of[...this.transientActors.keys()])this.releaseTransientActor(e,t)}subscribeObservable(t){let r=this.actor(t.actorId);null!=t.component&&(r=this.component(r,t.component));const n=this.getProperty(r,t.property);if(!e(n))throw new Error(`Event graph property ${JSON.stringify(t.property)} on actor ${JSON.stringify(t.actorId)} is not an RxJS Observable`);return n.subscribe(e=>this.dispatch([t],e))}subscribeEventSource(e){let t=this.actor(e.actorId);null!=e.component&&(t=this.component(t,e.component));const r=e.args.map(e=>this.resolveEventSourceArgument(e));return this.createEventSourceObservable(t,e.method,r).subscribe(t=>this.dispatch([e],t))}createEventSourceObservable(t,r,n){if(this.assertObject(t,"event source target"),!f(t,r))throw new Error(`Method ${JSON.stringify(r)} is not marked with @EventGraphEventSource`);const o=t[r];if("function"!=typeof o)throw new Error(`Event graph target has no event source ${JSON.stringify(r)}`);const s=o.apply(t,n);if(!e(s))throw new Error(`Event source ${JSON.stringify(r)} did not return an RxJS Observable`);return s}resolveEventSourceArgument(e){return"actor"===e.kind?this.actor(e.actorId):this.actorClass(e.classId)}dispatch(e,t){if(!this.ended||e===this.compiled.endPlay)for(const r of e)try{const e=this.invokeHandler(r,t);Q(e)&&e.catch(e=>this.reportError(e,r.eventNodeId))}catch(e){this.reportError(e,r.eventNodeId)}}assertExposedProperty(e,t){if(this.assertObject(e,"property target"),!v(e,t))throw new Error(`Property ${JSON.stringify(t)} is not marked with @EventGraphProperty`)}writableExposedPropertyInfo(e,t){this.assertObject(e,"property target");const r=w(e,t);if(null==r)throw new Error(`Property ${JSON.stringify(t)} is not marked with @EventGraphProperty`);if(!r.writable)throw new Error(`Property ${JSON.stringify(t)} is read-only`);return r}assertObject(e,t){if("object"!=typeof e&&"function"!=typeof e||null==e)throw new Error(`Event graph ${t} is not an object`)}unsubscribeAll(){for(const e of this.subscriptions)e.unsubscribe();this.subscriptions.length=0,this.dynamicEventSourceSubscriptions.clear(),this.updateSubscription=void 0}replaceDynamicEventSourceSubscription(e,t){const r=this.dynamicEventSourceSubscriptions.get(e);null!=r&&this.removeSubscription(r),this.dynamicEventSourceSubscriptions.delete(e),null!=t&&(this.dynamicEventSourceSubscriptions.set(e,t),this.subscriptions.push(t))}removeSubscription(e){e.unsubscribe();const t=this.subscriptions.indexOf(e);t>=0&&this.subscriptions.splice(t,1),this.updateSubscription===e&&(this.updateSubscription=void 0)}cancelDelays(){for(const e of this.pendingDelays)e.subscription?.unsubscribe(),e.reject(new D);this.pendingDelays.clear()}clearIntervals(){const e=this.options.timer;if(null!=e)for(const t of this.intervals.values())e.clearInterval(t);this.intervals.clear()}reportError(e,t){e instanceof D||(null==this.options.onError?console.error(`Event graph handler ${JSON.stringify(t)} failed`,e):this.options.onError(e,t))}}function g(e,t){if(null==e)return e;if("vector2"===t.kind){const t=e;return new s(t[0],t[1])}if("vector3"===t.kind){const t=e;return new i(t[0],t[1],t[2])}if("euler"===t.kind){const t=e;return new r(t[0],t[1],t[2])}if("asset"===t.kind)return e.assetId;if("actorClass"===t.kind){const t=l(String(e));if(null==t)throw new Error(`Event graph could not resolve actor class ${JSON.stringify(e)}`);return t}return"optional"===t.kind?g(e,t.value):"array"===t.kind&&Array.isArray(e)?e.map(e=>g(e,t.element)):structuredClone(e)}function E(e,t,r){if("optional"===t?.kind)return null==e?e:E(e,t.value,r);if("array"===t?.kind&&Array.isArray(e)){const n=Array.isArray(r)?r:void 0;return e.map((e,r)=>E(e,t.element,n?.[r]))}return!A(e)||null!=t&&"any"!==t.kind&&"vector2"!==t.kind?!P(e)||null!=t&&"any"!==t.kind&&"vector3"!==t.kind?!T(e)||null!=t&&"any"!==t.kind&&"euler"!==t.kind?e:T(r)?r.copy(e):e.clone():P(r)?r.copy(e):e.clone():A(r)?r.copy(e):e.clone()}function S(e){if("function"!=typeof e||e!==c&&!0!==e.__isActor&&!(e.prototype instanceof c))throw new Error("Event graph actor class input must be an actor type");return e}function T(e){return"object"==typeof e&&null!=e&&!0===e.isEuler}function A(e){return"object"==typeof e&&null!=e&&!0===e.isVector2}function P(e){return"object"==typeof e&&null!=e&&!0===e.isVector3}function V(e){return"number"==typeof e||A(e)}function k(e){return"number"==typeof e||P(e)}function x(e,t){return"number"==typeof e?e:e[t]}function I(e,t){return"number"==typeof e?e:e[t]}function O(e,t,r){switch(r){case"add":return e+t;case"subtract":return e-t;case"multiply":return e*t;case"divide":return e/t;case"modulo":return e%t}}function j(e,t,r){if("number"===t.type.kind){if("number"!=typeof e||!Number.isFinite(e))throw new Error(`Event graph tween ${r} value for ${JSON.stringify(t.propertyName)} must be a finite number`);return e}if("vector2"===t.type.kind&&A(e))return e.clone();if("vector3"===t.type.kind&&P(e))return e.clone();if("euler"===t.type.kind&&T(e))return e.clone();throw new Error(`Event graph tween ${r} value for ${JSON.stringify(t.propertyName)} must be ${t.type.kind}`)}function N(e,t,r,n){if(!Number.isFinite(e)||e<0)throw new Error("Event graph tween duration must be a finite non-negative number");return{duration:e,elapsed:0,curve:a.decode(t),completed:r,eventNodeId:n}}function q(e){if(!(e instanceof c))throw new Error("Event graph tween target must be an actor");return e}function $(e,t){if(!P(e))throw new Error(`${t} must be a Three.js Vector3`);return e}function J(e,t){if(!T(e))throw new Error(`${t} must be a Three.js Euler`);return e}function B(e){if("local"!==e&&"world"!==e)throw new Error(`Event graph transform space must be "local" or "world", received ${JSON.stringify(e)}`)}function M(e){if("x"===e)return new i(1,0,0);if("y"===e)return new i(0,1,0);if("z"===e)return new i(0,0,1);throw new Error(`Event graph rotation axis must be "x", "y", or "z", received ${JSON.stringify(e)}`)}class D extends Error{constructor(){super("Event graph execution was cancelled")}}function Q(e){return null!=e&&"function"==typeof e.then&&"function"==typeof e.catch}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */