@magicborn/dialogue-forge 0.1.0

package/dist/lib/yarn-runner/__tests__/condition-evaluator.test.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const condition_evaluator_1 = require("../condition-evaluator");
+const constants_1 = require("../../../types/constants");
+(0, vitest_1.describe)('condition-evaluator', () => {
+    (0, vitest_1.describe)('evaluateCondition', () => {
+        const variables = {
+            flag1: true,
+            flag2: false,
+            flag3: 42,
+            flag4: 'hello',
+            flag5: 0,
+        };
+        const memoryFlags = new Set(['memory1', 'memory2']);
+        (0, vitest_1.it)('should evaluate IS_SET correctly', () => {
+            const condition = {
+                flag: 'flag1',
+                operator: constants_1.CONDITION_OPERATOR.IS_SET,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag2',
+                operator: constants_1.CONDITION_OPERATOR.IS_SET,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(false);
+            const condition3 = {
+                flag: 'memory1',
+                operator: constants_1.CONDITION_OPERATOR.IS_SET,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition3, variables, memoryFlags)).toBe(true);
+        });
+        (0, vitest_1.it)('should evaluate IS_NOT_SET correctly', () => {
+            const condition = {
+                flag: 'nonexistent',
+                operator: constants_1.CONDITION_OPERATOR.IS_NOT_SET,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag1',
+                operator: constants_1.CONDITION_OPERATOR.IS_NOT_SET,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(false);
+        });
+        (0, vitest_1.it)('should evaluate EQUALS correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.EQUALS,
+                value: 42,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag4',
+                operator: constants_1.CONDITION_OPERATOR.EQUALS,
+                value: 'hello',
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(true);
+            const condition3 = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.EQUALS,
+                value: 10,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition3, variables, memoryFlags)).toBe(false);
+        });
+        (0, vitest_1.it)('should evaluate NOT_EQUALS correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.NOT_EQUALS,
+                value: 10,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.NOT_EQUALS,
+                value: 42,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(false);
+        });
+        (0, vitest_1.it)('should evaluate GREATER_THAN correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.GREATER_THAN,
+                value: 40,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.GREATER_THAN,
+                value: 50,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(false);
+        });
+        (0, vitest_1.it)('should evaluate LESS_THAN correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.LESS_THAN,
+                value: 50,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.LESS_THAN,
+                value: 40,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(false);
+        });
+        (0, vitest_1.it)('should evaluate GREATER_EQUAL correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.GREATER_EQUAL,
+                value: 42,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.GREATER_EQUAL,
+                value: 41,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(true);
+        });
+        (0, vitest_1.it)('should evaluate LESS_EQUAL correctly', () => {
+            const condition = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.LESS_EQUAL,
+                value: 42,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'flag3',
+                operator: constants_1.CONDITION_OPERATOR.LESS_EQUAL,
+                value: 43,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(true);
+        });
+        (0, vitest_1.it)('should treat undefined as 0 for numeric comparisons', () => {
+            const condition = {
+                flag: 'nonexistent',
+                operator: constants_1.CONDITION_OPERATOR.GREATER_THAN,
+                value: -1,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition, variables, memoryFlags)).toBe(true);
+            const condition2 = {
+                flag: 'nonexistent',
+                operator: constants_1.CONDITION_OPERATOR.LESS_THAN,
+                value: 1,
+            };
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateCondition)(condition2, variables, memoryFlags)).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('evaluateConditions', () => {
+        const variables = {
+            flag1: true,
+            flag2: 42,
+        };
+        (0, vitest_1.it)('should return true when all conditions are true', () => {
+            const conditions = [
+                { flag: 'flag1', operator: constants_1.CONDITION_OPERATOR.IS_SET },
+                { flag: 'flag2', operator: constants_1.CONDITION_OPERATOR.EQUALS, value: 42 },
+            ];
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateConditions)(conditions, variables)).toBe(true);
+        });
+        (0, vitest_1.it)('should return false when any condition is false', () => {
+            const conditions = [
+                { flag: 'flag1', operator: constants_1.CONDITION_OPERATOR.IS_SET },
+                { flag: 'flag2', operator: constants_1.CONDITION_OPERATOR.EQUALS, value: 10 },
+            ];
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateConditions)(conditions, variables)).toBe(false);
+        });
+        (0, vitest_1.it)('should return true for empty conditions array', () => {
+            (0, vitest_1.expect)((0, condition_evaluator_1.evaluateConditions)([], variables)).toBe(true);
+        });
+    });
+});

package/dist/lib/yarn-runner/__tests__/node-processor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/yarn-runner/__tests__/node-processor.test.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_processor_1 = require("../node-processor");
+const variable_manager_1 = require("../variable-manager");
+(0, vitest_1.describe)('node-processor', () => {
+    let variableManager;
+    let availableNodes;
+    (0, vitest_1.beforeEach)(() => {
+        variableManager = new variable_manager_1.VariableManager({ flag1: true, flag2: 42 });
+        availableNodes = {
+            node1: {
+                id: 'node1',
+                type: 'npc',
+                content: 'Hello',
+                x: 0,
+                y: 0,
+            },
+            node2: {
+                id: 'node2',
+                type: 'npc',
+                content: 'World',
+                x: 0,
+                y: 0,
+            },
+        };
+    });
+    (0, vitest_1.describe)('processNode', () => {
+        (0, vitest_1.describe)('NPC nodes', () => {
+            (0, vitest_1.it)('should process simple NPC node', () => {
+                const node = {
+                    id: 'test',
+                    type: 'npc',
+                    content: 'Hello world',
+                    speaker: 'NPC',
+                    nextNodeId: 'node1',
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.content).toBe('Hello world');
+                (0, vitest_1.expect)(result.speaker).toBe('NPC');
+                (0, vitest_1.expect)(result.nextNodeId).toBe('node1');
+                (0, vitest_1.expect)(result.isEnd).toBe(false);
+                (0, vitest_1.expect)(result.isPlayerChoice).toBe(false);
+            });
+            (0, vitest_1.it)('should mark as end when no nextNodeId', () => {
+                const node = {
+                    id: 'test',
+                    type: 'npc',
+                    content: 'End',
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.isEnd).toBe(true);
+                (0, vitest_1.expect)(result.nextNodeId).toBeUndefined();
+            });
+        });
+        (0, vitest_1.describe)('Player nodes', () => {
+            (0, vitest_1.it)('should return choices for player node', () => {
+                const node = {
+                    id: 'test',
+                    type: 'player',
+                    content: '',
+                    choices: [
+                        {
+                            id: 'c1',
+                            text: 'Choice 1',
+                            nextNodeId: 'node1',
+                        },
+                        {
+                            id: 'c2',
+                            text: 'Choice 2',
+                            nextNodeId: 'node2',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.isPlayerChoice).toBe(true);
+                (0, vitest_1.expect)(result.choices).toHaveLength(2);
+                (0, vitest_1.expect)(result.choices?.[0].text).toBe('Choice 1');
+            });
+            (0, vitest_1.it)('should filter choices based on conditions', () => {
+                const node = {
+                    id: 'test',
+                    type: 'player',
+                    content: '',
+                    choices: [
+                        {
+                            id: 'c1',
+                            text: 'Choice 1',
+                            nextNodeId: 'node1',
+                            conditions: [
+                                { flag: 'flag1', operator: 'is_set' },
+                            ],
+                        },
+                        {
+                            id: 'c2',
+                            text: 'Choice 2',
+                            nextNodeId: 'node2',
+                            conditions: [
+                                { flag: 'flag3', operator: 'is_set' },
+                            ],
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.choices).toHaveLength(1);
+                (0, vitest_1.expect)(result.choices?.[0].text).toBe('Choice 1');
+            });
+        });
+        (0, vitest_1.describe)('Conditional nodes', () => {
+            (0, vitest_1.it)('should process conditional node with matching if block', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag1', operator: 'is_set' }],
+                            content: 'If content',
+                            speaker: 'Speaker',
+                            nextNodeId: 'node1',
+                        },
+                        {
+                            id: 'b2',
+                            type: 'else',
+                            content: 'Else content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.content).toBe('If content');
+                (0, vitest_1.expect)(result.speaker).toBe('Speaker');
+                (0, vitest_1.expect)(result.nextNodeId).toBe('node1');
+            });
+            (0, vitest_1.it)('should process conditional node with matching elseif block', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag3', operator: 'is_set' }],
+                            content: 'If content',
+                        },
+                        {
+                            id: 'b2',
+                            type: 'elseif',
+                            condition: [{ flag: 'flag1', operator: 'is_set' }],
+                            content: 'Elseif content',
+                        },
+                        {
+                            id: 'b3',
+                            type: 'else',
+                            content: 'Else content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.content).toBe('Elseif content');
+            });
+            (0, vitest_1.it)('should process conditional node with else block when no conditions match', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag3', operator: 'is_set' }],
+                            content: 'If content',
+                        },
+                        {
+                            id: 'b2',
+                            type: 'else',
+                            content: 'Else content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.content).toBe('Else content');
+            });
+            (0, vitest_1.it)('should return end when no block matches', () => {
+                const node = {
+                    id: 'test',
+                    type: 'conditional',
+                    content: '',
+                    conditionalBlocks: [
+                        {
+                            id: 'b1',
+                            type: 'if',
+                            condition: [{ flag: 'flag3', operator: 'is_set' }],
+                            content: 'If content',
+                        },
+                    ],
+                    x: 0,
+                    y: 0,
+                };
+                const result = (0, node_processor_1.processNode)(node, variableManager);
+                (0, vitest_1.expect)(result.isEnd).toBe(true);
+                (0, vitest_1.expect)(result.content).toBe('');
+            });
+        });
+    });
+    (0, vitest_1.describe)('isValidNextNode', () => {
+        (0, vitest_1.it)('should return true for valid node ID', () => {
+            (0, vitest_1.expect)((0, node_processor_1.isValidNextNode)('node1', availableNodes)).toBe(true);
+        });
+        (0, vitest_1.it)('should return false for undefined', () => {
+            (0, vitest_1.expect)((0, node_processor_1.isValidNextNode)(undefined, availableNodes)).toBe(false);
+        });
+        (0, vitest_1.it)('should return false for empty string', () => {
+            (0, vitest_1.expect)((0, node_processor_1.isValidNextNode)('', availableNodes)).toBe(false);
+        });
+        (0, vitest_1.it)('should return false for whitespace-only string', () => {
+            (0, vitest_1.expect)((0, node_processor_1.isValidNextNode)('   ', availableNodes)).toBe(false);
+        });
+        (0, vitest_1.it)('should return false for non-existent node', () => {
+            (0, vitest_1.expect)((0, node_processor_1.isValidNextNode)('nonexistent', availableNodes)).toBe(false);
+        });
+    });
+});

package/dist/lib/yarn-runner/__tests__/variable-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/yarn-runner/__tests__/variable-manager.test.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const variable_manager_1 = require("../variable-manager");
+(0, vitest_1.describe)('VariableManager', () => {
+    let manager;
+    (0, vitest_1.beforeEach)(() => {
+        manager = new variable_manager_1.VariableManager();
+    });
+    (0, vitest_1.describe)('constructor', () => {
+        (0, vitest_1.it)('should initialize with empty state by default', () => {
+            (0, vitest_1.expect)(manager.get('test')).toBeUndefined();
+            (0, vitest_1.expect)(manager.getAllMemoryFlags().size).toBe(0);
+        });
+        (0, vitest_1.it)('should initialize with provided variables', () => {
+            const vars = { flag1: true, flag2: 42 };
+            const manager2 = new variable_manager_1.VariableManager(vars);
+            (0, vitest_1.expect)(manager2.get('flag1')).toBe(true);
+            (0, vitest_1.expect)(manager2.get('flag2')).toBe(42);
+        });
+        (0, vitest_1.it)('should initialize with provided memory flags', () => {
+            const memoryFlags = new Set(['mem1', 'mem2']);
+            const manager2 = new variable_manager_1.VariableManager(undefined, memoryFlags);
+            (0, vitest_1.expect)(manager2.hasMemoryFlag('mem1')).toBe(true);
+            (0, vitest_1.expect)(manager2.hasMemoryFlag('mem2')).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('set and get', () => {
+        (0, vitest_1.it)('should set and get boolean values', () => {
+            manager.set('flag1', true);
+            (0, vitest_1.expect)(manager.get('flag1')).toBe(true);
+        });
+        (0, vitest_1.it)('should set and get number values', () => {
+            manager.set('flag2', 42);
+            (0, vitest_1.expect)(manager.get('flag2')).toBe(42);
+        });
+        (0, vitest_1.it)('should set and get string values', () => {
+            manager.set('flag3', 'hello');
+            (0, vitest_1.expect)(manager.get('flag3')).toBe('hello');
+        });
+        (0, vitest_1.it)('should return undefined for unset variables', () => {
+            (0, vitest_1.expect)(manager.get('nonexistent')).toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)('memory flags', () => {
+        (0, vitest_1.it)('should add memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            (0, vitest_1.expect)(manager.hasMemoryFlag('mem1')).toBe(true);
+            (0, vitest_1.expect)(manager.get('mem1')).toBe(true);
+        });
+        (0, vitest_1.it)('should remove memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            manager.removeMemoryFlag('mem1');
+            (0, vitest_1.expect)(manager.hasMemoryFlag('mem1')).toBe(false);
+        });
+        (0, vitest_1.it)('should return memory flags as true when getting', () => {
+            manager.addMemoryFlag('mem1');
+            (0, vitest_1.expect)(manager.get('mem1')).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('getAllVariables', () => {
+        (0, vitest_1.it)('should return a copy of all variables', () => {
+            manager.set('flag1', true);
+            manager.set('flag2', 42);
+            const vars = manager.getAllVariables();
+            (0, vitest_1.expect)(vars).toEqual({ flag1: true, flag2: 42 });
+            // Should be a copy, not a reference
+            vars.flag1 = false;
+            (0, vitest_1.expect)(manager.get('flag1')).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('getAllMemoryFlags', () => {
+        (0, vitest_1.it)('should return a copy of memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            manager.addMemoryFlag('mem2');
+            const flags = manager.getAllMemoryFlags();
+            (0, vitest_1.expect)(flags.has('mem1')).toBe(true);
+            (0, vitest_1.expect)(flags.has('mem2')).toBe(true);
+            // Should be a copy
+            flags.delete('mem1');
+            (0, vitest_1.expect)(manager.hasMemoryFlag('mem1')).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('clearMemoryFlags', () => {
+        (0, vitest_1.it)('should clear all memory flags', () => {
+            manager.addMemoryFlag('mem1');
+            manager.addMemoryFlag('mem2');
+            manager.clearMemoryFlags();
+            (0, vitest_1.expect)(manager.getAllMemoryFlags().size).toBe(0);
+        });
+    });
+    (0, vitest_1.describe)('reset', () => {
+        (0, vitest_1.it)('should reset to initial state', () => {
+            manager.set('flag1', true);
+            manager.addMemoryFlag('mem1');
+            manager.reset();
+            (0, vitest_1.expect)(manager.get('flag1')).toBeUndefined();
+            (0, vitest_1.expect)(manager.hasMemoryFlag('mem1')).toBe(false);
+        });
+        (0, vitest_1.it)('should reset to provided state', () => {
+            manager.set('flag1', true);
+            manager.reset({ flag2: 42 }, new Set(['mem2']));
+            (0, vitest_1.expect)(manager.get('flag1')).toBeUndefined();
+            (0, vitest_1.expect)(manager.get('flag2')).toBe(42);
+            (0, vitest_1.expect)(manager.hasMemoryFlag('mem2')).toBe(true);
+        });
+    });
+});

package/dist/lib/yarn-runner/condition-evaluator.d.ts

@@ -0,0 +1,12 @@
+import { Condition } from '../../types';
+export interface VariableState {
+    [key: string]: boolean | number | string | undefined;
+}
+/**
+ * Evaluates a single condition against variable state
+ */
+export declare function evaluateCondition(condition: Condition, variables: VariableState, memoryFlags?: Set<string>): boolean;
+/**
+ * Evaluates multiple conditions with AND logic
+ */
+export declare function evaluateConditions(conditions: Condition[], variables: VariableState, memoryFlags?: Set<string>): boolean;

package/dist/lib/yarn-runner/condition-evaluator.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateCondition = evaluateCondition;
+exports.evaluateConditions = evaluateConditions;
+const constants_1 = require("../../types/constants");
+/**
+ * Evaluates a single condition against variable state
+ */
+function evaluateCondition(condition, variables, memoryFlags) {
+    let value = variables[condition.flag];
+    // If not in variables, check memoryFlags (dialogue flags)
+    if (value === undefined && memoryFlags) {
+        value = memoryFlags.has(condition.flag) ? true : undefined;
+    }
+    // For numeric comparisons, treat undefined as 0
+    const numericOperators = [
+        constants_1.CONDITION_OPERATOR.GREATER_THAN,
+        constants_1.CONDITION_OPERATOR.LESS_THAN,
+        constants_1.CONDITION_OPERATOR.GREATER_EQUAL,
+        constants_1.CONDITION_OPERATOR.LESS_EQUAL
+    ];
+    const isNumericComparison = numericOperators.includes(condition.operator);
+    if (isNumericComparison && value === undefined) {
+        value = 0;
+    }
+    switch (condition.operator) {
+        case constants_1.CONDITION_OPERATOR.IS_SET:
+            return value !== undefined && value !== false && value !== 0 && value !== '';
+        case constants_1.CONDITION_OPERATOR.IS_NOT_SET:
+            return value === undefined || value === false || value === 0 || value === '';
+        case constants_1.CONDITION_OPERATOR.EQUALS:
+            return value === condition.value;
+        case constants_1.CONDITION_OPERATOR.NOT_EQUALS:
+            return value !== condition.value;
+        case constants_1.CONDITION_OPERATOR.GREATER_THAN:
+            const numValueGT = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondGT = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueGT) && !isNaN(numCondGT) && numValueGT > numCondGT;
+        case constants_1.CONDITION_OPERATOR.LESS_THAN:
+            const numValueLT = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondLT = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueLT) && !isNaN(numCondLT) && numValueLT < numCondLT;
+        case constants_1.CONDITION_OPERATOR.GREATER_EQUAL:
+            const numValueGE = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondGE = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueGE) && !isNaN(numCondGE) && numValueGE >= numCondGE;
+        case constants_1.CONDITION_OPERATOR.LESS_EQUAL:
+            const numValueLE = typeof value === 'number' ? value : (typeof value === 'string' ? parseFloat(value) : 0);
+            const numCondLE = typeof condition.value === 'number' ? condition.value : parseFloat(String(condition.value));
+            return !isNaN(numValueLE) && !isNaN(numCondLE) && numValueLE <= numCondLE;
+        default:
+            return true;
+    }
+}
+/**
+ * Evaluates multiple conditions with AND logic
+ */
+function evaluateConditions(conditions, variables, memoryFlags) {
+    return conditions.every(cond => evaluateCondition(cond, variables, memoryFlags));
+}

package/dist/lib/yarn-runner/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Yarn Spinner Runner
+ *
+ * Modular execution engine for running Yarn Spinner dialogue trees.
+ * This module provides the core logic for processing nodes, evaluating conditions,
+ * and managing state, separate from the UI components.
+ */
+export { VariableManager } from './variable-manager';
+export { evaluateCondition, evaluateConditions } from './condition-evaluator';
+export { processNode, isValidNextNode, ProcessedNodeResult } from './node-processor';
+export { executeVariableOperation, processVariableOperationsInContent } from './variable-operations';
+export type { VariableState } from './condition-evaluator';

package/dist/lib/yarn-runner/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Yarn Spinner Runner
+ *
+ * Modular execution engine for running Yarn Spinner dialogue trees.
+ * This module provides the core logic for processing nodes, evaluating conditions,
+ * and managing state, separate from the UI components.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processVariableOperationsInContent = exports.executeVariableOperation = exports.isValidNextNode = exports.processNode = exports.evaluateConditions = exports.evaluateCondition = exports.VariableManager = void 0;
+var variable_manager_1 = require("./variable-manager");
+Object.defineProperty(exports, "VariableManager", { enumerable: true, get: function () { return variable_manager_1.VariableManager; } });
+var condition_evaluator_1 = require("./condition-evaluator");
+Object.defineProperty(exports, "evaluateCondition", { enumerable: true, get: function () { return condition_evaluator_1.evaluateCondition; } });
+Object.defineProperty(exports, "evaluateConditions", { enumerable: true, get: function () { return condition_evaluator_1.evaluateConditions; } });
+var node_processor_1 = require("./node-processor");
+Object.defineProperty(exports, "processNode", { enumerable: true, get: function () { return node_processor_1.processNode; } });
+Object.defineProperty(exports, "isValidNextNode", { enumerable: true, get: function () { return node_processor_1.isValidNextNode; } });
+var variable_operations_1 = require("./variable-operations");
+Object.defineProperty(exports, "executeVariableOperation", { enumerable: true, get: function () { return variable_operations_1.executeVariableOperation; } });
+Object.defineProperty(exports, "processVariableOperationsInContent", { enumerable: true, get: function () { return variable_operations_1.processVariableOperationsInContent; } });

package/dist/lib/yarn-runner/node-processor.d.ts

@@ -0,0 +1,18 @@
+import { DialogueNode, Choice } from '../../types';
+import { VariableManager } from './variable-manager';
+export interface ProcessedNodeResult {
+    content: string;
+    speaker?: string;
+    nextNodeId?: string;
+    isEnd: boolean;
+    isPlayerChoice: boolean;
+    choices?: Choice[];
+}
+/**
+ * Processes a dialogue node and returns the result
+ */
+export declare function processNode(node: DialogueNode, variableManager: VariableManager): ProcessedNodeResult;
+/**
+ * Validates that a nextNodeId exists and is valid
+ */
+export declare function isValidNextNode(nextNodeId: string | undefined, availableNodes: Record<string, DialogueNode>): boolean;