@vylos/core 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vylos/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/DevOpsBenjamin/Vylos"
@@ -19,8 +19,7 @@
     "pinia-plugin-persistedstate": "^3.2.3",
     "reflect-metadata": "^0.2.2",
     "tsyringe": "^4.8.0",
-    "vue": "^3.5.13",
-    "zod": "^3.24.1"
+    "vue": "^3.5.13"
   },
   "devDependencies": {
     "@vue/test-utils": "^2.4.6",

package/src/components/core/DialogueBox.vue

@@ -7,8 +7,12 @@
     >
       <div class="dlg-box" :class="{ 'dlg-box--history': engineState.historyBrowsing }">
         <!-- Speaker name -->
-        <div v-if="engineState.dialogue.speaker" class="dlg-speaker">
-          {{ engineState.dialogue.speaker }}
+        <div
+          v-if="engineState.dialogue.speaker"
+          class="dlg-speaker"
+          :style="engineState.dialogue.speaker.color ? { color: engineState.dialogue.speaker.color } : undefined"
+        >
+          {{ speakerName }}
         </div>
 
         <!-- Dialogue text -->
@@ -31,13 +35,21 @@
 </template>
 
 <script setup lang="ts">
-import { inject } from 'vue';
+import { inject, computed } from 'vue';
 import { useEngineStateStore } from '../../stores/engineState';
 import { ENGINE_INJECT_KEY } from '../../composables/useEngine';
+import { useLanguage } from '../../composables/useLanguage';
 import type { Engine } from '../../engine/core/Engine';
 
 const engineState = useEngineStateStore();
 const engine = inject<Engine>(ENGINE_INJECT_KEY);
+const { resolveText } = useLanguage();
+
+const speakerName = computed(() => {
+  const speaker = engineState.dialogue?.speaker;
+  if (!speaker) return '';
+  return resolveText(speaker.name);
+});
 
 function handleClick(): void {
   if (!engine) return;
@@ -115,7 +127,7 @@ function handleClick(): void {
 }
 
 .dlg-speaker {
-  color: #fde047;
+  color: #fde047; /* default — overridden by Character.color via :style */
   font-weight: 700;
   font-size: 1.8cqw;
   margin-bottom: 1cqh;

package/src/engine/core/CheckpointManager.ts

@@ -1,5 +1,5 @@
 import { toRaw } from 'vue';
-import type { BaseGameState, Checkpoint, CheckpointType, ChoiceOption } from '../types';
+import type { VylosGameState, Checkpoint, CheckpointType, ChoiceOption } from '../types';
 import type { DialogueState } from '../types/engine';
 
 export interface CaptureDisplayData {
@@ -38,7 +38,7 @@ export class CheckpointManager {
   }
 
   /** Record a checkpoint at the current interaction point */
-  capture(gameState: BaseGameState, type: CheckpointType, choiceResult?: string, display?: CaptureDisplayData): void {
+  capture(gameState: VylosGameState, type: CheckpointType, choiceResult?: string, display?: CaptureDisplayData): void {
     const checkpoint: Checkpoint = {
       step: this.checkpoints.length,
       gameState: structuredClone(toRaw(gameState)),
@@ -72,7 +72,7 @@ export class CheckpointManager {
   }
 
   /** Get game state snapshot at a specific step */
-  getStateAt(step: number): BaseGameState | undefined {
+  getStateAt(step: number): VylosGameState | undefined {
     const checkpoint = this.checkpoints[step];
     if (!checkpoint) return undefined;
     return structuredClone(checkpoint.gameState);
@@ -84,7 +84,7 @@ export class CheckpointManager {
   }
 
   /** Prepare for rollback: set replay index to target step */
-  prepareRollback(targetStep: number): BaseGameState | undefined {
+  prepareRollback(targetStep: number): VylosGameState | undefined {
     if (targetStep < 0 || targetStep >= this.checkpoints.length) return undefined;
     this.replayIndex = 0;
     // Trim checkpoints after target (re-execution will recreate them)

package/src/engine/core/Engine.ts

@@ -1,23 +1,26 @@
-import type { VylosEvent, BaseGameState, Checkpoint, SaveSlot } from '../types';
+import type { VylosEvent, VylosGameState, Checkpoint, SaveSlot } from '../types';
 import { EventManager } from '../managers/EventManager';
 import { HistoryManager } from '../managers/HistoryManager';
+import { InventoryManager } from '../managers/InventoryManager';
 import { NavigationManager, NavigationAction } from '../managers/NavigationManager';
 import { SaveManager } from '../managers/SaveManager';
 import { SettingsManager } from '../managers/SettingsManager';
 import { EventRunner } from './EventRunner';
 import { JumpSignal } from '../errors/JumpSignal';
 import { logger } from '../utils/logger';
+import { attachDevConsole } from '../utils/devConsole';
 
 export interface EngineLoopCallbacks {
   /** Called each loop iteration (update UI: available locations, actions, background) */
-  onTick?(state: BaseGameState): void;
+  onTick?(state: VylosGameState): void;
   /** Called when player selects an action */
-  onAction?(actionId: string, state: BaseGameState): void;
+  onAction?(actionId: string, state: VylosGameState): void;
 }
 
 export interface EngineDeps {
   eventManager: EventManager;
   historyManager: HistoryManager;
+  inventoryManager: InventoryManager;
   navigationManager: NavigationManager;
   eventRunner: EventRunner;
   saveManager: SaveManager;
@@ -31,6 +34,7 @@ export interface EngineDeps {
 export class Engine {
   readonly eventManager: EventManager;
   readonly historyManager: HistoryManager;
+  readonly inventoryManager: InventoryManager;
   readonly navigationManager: NavigationManager;
   readonly eventRunner: EventRunner;
   readonly saveManager: SaveManager;
@@ -41,7 +45,7 @@ export class Engine {
   private pendingResume: {
     eventId: string;
     checkpoints: Checkpoint[];
-    initialState: BaseGameState;
+    initialState: VylosGameState;
   } | null = null;
 
   /** Flag to skip event lock/push when interrupted by a load */
@@ -50,6 +54,7 @@ export class Engine {
   constructor(deps: EngineDeps) {
     this.eventManager = deps.eventManager;
     this.historyManager = deps.historyManager;
+    this.inventoryManager = deps.inventoryManager;
     this.navigationManager = deps.navigationManager;
     this.eventRunner = deps.eventRunner;
     this.saveManager = deps.saveManager;
@@ -57,9 +62,10 @@ export class Engine {
   }
 
   /** Register events and start the game loop */
-  async run(events: VylosEvent[], getState: () => BaseGameState, loop?: EngineLoopCallbacks): Promise<void> {
+  async run(events: VylosEvent[], getState: () => VylosGameState, loop?: EngineLoopCallbacks): Promise<void> {
     this.eventManager.registerAll(events);
     this.running = true;
+    attachDevConsole(this, getState);
 
     logger.info('Engine started');
 
@@ -131,7 +137,7 @@ export class Engine {
    * Load a save and resume execution.
    * Restores game state, history, event lock state, and sets up mid-event resume if needed.
    */
-  loadSave(saveData: SaveSlot, setState: (state: BaseGameState) => void): void {
+  loadSave(saveData: SaveSlot, setState: (state: VylosGameState) => void): void {
     // Restore game state
     setState(JSON.parse(JSON.stringify(saveData.gameState)));
 
@@ -164,7 +170,7 @@ export class Engine {
   }
 
   /** Execute a single event, handling jumps */
-  private async executeEvent(event: VylosEvent, getState: () => BaseGameState): Promise<void> {
+  private async executeEvent(event: VylosEvent, getState: () => VylosGameState): Promise<void> {
     let currentEvent: VylosEvent | undefined = event;
 
     while (currentEvent) {
@@ -208,7 +214,7 @@ export class Engine {
   }
 
   /** Handle resuming a mid-event save */
-  private async handleResume(getState: () => BaseGameState): Promise<void> {
+  private async handleResume(getState: () => VylosGameState): Promise<void> {
     const resume = this.pendingResume!;
     this.pendingResume = null;
 

package/src/engine/core/EngineFactory.ts

@@ -10,6 +10,7 @@ import { SaveManager } from '../managers/SaveManager';
 import { SettingsManager } from '../managers/SettingsManager';
 import { EventRunner, type EventRunnerCallbacks } from './EventRunner';
 import { CheckpointManager } from './CheckpointManager';
+import { InventoryManager } from '../managers/InventoryManager';
 import { VylosStorage } from '../storage/VylosStorage';
 import { Engine } from './Engine';
 
@@ -20,6 +21,7 @@ export const DI_TOKENS = {
   NavigationManager: 'NavigationManager',
   WaitManager: 'WaitManager',
   CheckpointManager: 'CheckpointManager',
+  InventoryManager: 'InventoryManager',
   EventRunner: 'EventRunner',
   Engine: 'Engine',
 } as const;
@@ -34,6 +36,7 @@ function registerDefaults(c: DependencyContainer): void {
   c.register(DI_TOKENS.NavigationManager, { useClass: NavigationManager });
   c.register(DI_TOKENS.WaitManager, { useClass: WaitManager });
   c.register(DI_TOKENS.CheckpointManager, { useClass: CheckpointManager });
+  c.register(DI_TOKENS.InventoryManager, { useClass: InventoryManager });
 }
 
 export interface CreateEngineOptions {
@@ -72,9 +75,10 @@ export function createEngine(options: CreateEngineOptions): Engine {
   const eventManager = childContainer.resolve<EventManager>(DI_TOKENS.EventManager);
   const historyManager = childContainer.resolve<HistoryManager>(DI_TOKENS.HistoryManager);
   const navigationManager = childContainer.resolve<NavigationManager>(DI_TOKENS.NavigationManager);
+  const inventoryManager = childContainer.resolve<InventoryManager>(DI_TOKENS.InventoryManager);
 
-  // EventRunner needs callbacks, so we construct it directly
-  const eventRunner = new EventRunner(options.callbacks);
+  // EventRunner needs callbacks + inventoryManager, so we construct it directly
+  const eventRunner = new EventRunner(options.callbacks, inventoryManager);
 
   // Storage + persistence managers
   const storage = new VylosStorage(options.projectId ?? 'default');
@@ -88,6 +92,7 @@ export function createEngine(options: CreateEngineOptions): Engine {
     eventRunner,
     saveManager,
     settingsManager,
+    inventoryManager,
   });
 }
 

package/src/engine/core/EventRunner.ts

@@ -1,15 +1,18 @@
 import { toRaw } from 'vue';
 import type {
   VylosAPI,
+  InventoryAPI,
   VylosEvent,
-  BaseGameState,
+  VylosGameState,
   TextEntry,
   SayOptions,
   ChoiceItem,
   CheckpointType,
   ChoiceOption,
   DialogueState,
+  VylosCharacter,
 } from '../types';
+import { InventoryManager } from '../managers/InventoryManager';
 import { CheckpointManager } from './CheckpointManager';
 import { WaitManager } from '../managers/WaitManager';
 import { JumpSignal } from '../errors/JumpSignal';
@@ -20,7 +23,7 @@ import { interpolate } from '../utils/TimeHelper';
 
 export interface EventRunnerCallbacks {
   /** Called when dialogue should be displayed */
-  onSay(text: string, speaker: string | null): void;
+  onSay(text: string, speaker: VylosCharacter | null): void;
   /** Called when choices should be displayed */
   onChoice(options: Array<{ text: string; value: string; disabled?: boolean }>): void;
   /** Called to update background */
@@ -38,9 +41,9 @@ export interface EventRunnerCallbacks {
   /** Resolve a TextEntry to a string using current language */
   resolveText(entry: string | TextEntry): string;
   /** Get current game state */
-  getState(): BaseGameState;
+  getState(): VylosGameState;
   /** Set game state (after rollback) */
-  setState(state: BaseGameState): void;
+  setState(state: VylosGameState): void;
 }
 
 /** Data returned when browsing history steps */
@@ -71,22 +74,39 @@ export class EventRunner implements VylosAPI {
   /** History browsing index (-1 = live, not browsing) */
   private browseIndex = -1;
   /** The live dialogue being displayed when history browsing started */
-  private liveDialogue: { text: string; speaker: string | null } | null = null;
+  private liveDialogue: { text: string; speaker: VylosCharacter | null } | null = null;
   /** Current background path (tracked for checkpoint storage) */
   private currentBackground: string | null = null;
 
   /** Snapshot of game state before event started (for redo) */
-  private initialState: BaseGameState | null = null;
+  private initialState: VylosGameState | null = null;
   /** Reference to the currently executing event (for redo) */
   private currentEvent: VylosEvent | null = null;
   /** Pending redo request (set by UI, consumed by redo loop) */
   private pendingRedo: { step: number; choice: string } | null = null;
 
-  constructor(callbacks: EventRunnerCallbacks) {
+  private inventoryManager: InventoryManager;
+
+  constructor(callbacks: EventRunnerCallbacks, inventoryManager: InventoryManager) {
     this.callbacks = callbacks;
+    this.inventoryManager = inventoryManager;
     this.checkpoints = new CheckpointManager();
   }
 
+  get inventory(): InventoryAPI {
+    const inv = () => this.callbacks.getState().inventories;
+    const im = this.inventoryManager;
+    return {
+      add: (bag, itemId, qty) => im.add(inv(), bag, itemId, qty),
+      remove: (bag, itemId, qty) => im.remove(inv(), bag, itemId, qty),
+      has: (bag, itemId, qty) => im.has(inv(), bag, itemId, qty),
+      hasAll: (bag, items) => im.hasAll(inv(), bag, items),
+      count: (bag, itemId) => im.count(inv(), bag, itemId),
+      list: (bag) => im.list(inv(), bag),
+      clear: (bag) => im.clearBag(inv(), bag),
+    };
+  }
+
   /** Whether the player is browsing text history */
   get isBrowsingHistory(): boolean {
     return this.browseIndex >= 0;
@@ -98,12 +118,12 @@ export class EventRunner implements VylosAPI {
   }
 
   /** Get initial state snapshot for save (deep clone) */
-  getInitialState(): BaseGameState | null {
+  getInitialState(): VylosGameState | null {
     return this.initialState ? structuredClone(this.initialState) : null;
   }
 
   /** Get the live dialogue for restoring display after exiting history */
-  getLiveDialogue(): { text: string; speaker: string | null } | null {
+  getLiveDialogue(): { text: string; speaker: VylosCharacter | null } | null {
     return this.liveDialogue;
   }
 
@@ -207,7 +227,7 @@ export class EventRunner implements VylosAPI {
   }
 
   /** Resume a saved mid-event execution (for load). Checkpoints must be restored externally first. */
-  async resumeEvent(event: VylosEvent, savedInitialState: BaseGameState): Promise<void> {
+  async resumeEvent(event: VylosEvent, savedInitialState: VylosGameState): Promise<void> {
     this.initialState = structuredClone(savedInitialState);
     this.currentEvent = event;
     this.currentStep = 0;
@@ -248,10 +268,7 @@ export class EventRunner implements VylosAPI {
     }
 
     // Resolve speaker
-    let speaker: string | null = null;
-    if (options?.from) {
-      speaker = this.callbacks.resolveText(options.from);
-    }
+    const speaker: VylosCharacter | null = options?.from ?? null;
 
     // If replaying, fast-forward: capture checkpoint and resolve immediately
     if (this.checkpoints.isReplaying) {

package/src/engine/managers/ActionManager.ts

@@ -1,4 +1,4 @@
-import type { VylosAction, BaseGameState, TextEntry } from '../types';
+import type { VylosAction, VylosGameState, TextEntry } from '../types';
 import { logger } from '../utils/logger';
 
 /**
@@ -26,7 +26,7 @@ export class ActionManager {
   }
 
   /** Get all available actions for a location, filtered by unlock conditions */
-  getAvailable(locationId: string, state: BaseGameState): VylosAction[] {
+  getAvailable(locationId: string, state: VylosGameState): VylosAction[] {
     const available: VylosAction[] = [];
 
     for (const action of this.actions.values()) {
@@ -43,7 +43,7 @@ export class ActionManager {
   }
 
   /** Execute an action by ID */
-  execute(id: string, state: BaseGameState): boolean {
+  execute(id: string, state: VylosGameState): boolean {
     const action = this.actions.get(id);
     if (!action) {
       logger.warn(`Action not found: ${id}`);

package/src/engine/managers/EventManager.ts

@@ -1,4 +1,4 @@
-import type { VylosEvent, BaseGameState, DrawableEventEntry } from '../types';
+import type { VylosEvent, VylosGameState, DrawableEventEntry } from '../types';
 import { EventStatus } from '../types';
 import { logger } from '../utils/logger';
 
@@ -46,7 +46,7 @@ export class EventManager {
   }
 
   /** Evaluate conditions and update statuses. Returns newly unlocked events. */
-  evaluate(state: BaseGameState): VylosEvent[] {
+  evaluate(state: VylosGameState): VylosEvent[] {
     const unlocked: VylosEvent[] = [];
 
     for (const [id, entry] of this.events) {
@@ -68,7 +68,7 @@ export class EventManager {
   }
 
   /** Get the next unlocked event matching the current location (first registered wins). Skips drawable events. */
-  getNextUnlocked(state: BaseGameState): VylosEvent | undefined {
+  getNextUnlocked(state: VylosGameState): VylosEvent | undefined {
     for (const entry of this.events.values()) {
       if (entry.status !== EventStatus.Unlocked) continue;
       if (entry.event.draw) continue; // Drawable events don't auto-trigger
@@ -79,7 +79,7 @@ export class EventManager {
   }
 
   /** Get all unlocked drawable events at the current location */
-  getDrawableEvents(state: BaseGameState, resolveText?: (text: string | Record<string, string>) => string): DrawableEventEntry[] {
+  getDrawableEvents(state: VylosGameState, resolveText?: (text: string | Record<string, string>) => string): DrawableEventEntry[] {
     const result: DrawableEventEntry[] = [];
     for (const entry of this.events.values()) {
       if (entry.status !== EventStatus.Unlocked) continue;
@@ -108,7 +108,7 @@ export class EventManager {
   }
 
   /** Mark event as locked (completed) */
-  setLocked(id: string, state: BaseGameState): void {
+  setLocked(id: string, state: VylosGameState): void {
     const entry = this.events.get(id);
     if (entry) {
       entry.status = EventStatus.Locked;

package/src/engine/managers/InventoryManager.ts

@@ -0,0 +1,149 @@
+import type { VylosCategory, VylosItem, InventoryData } from '../types';
+
+/**
+ * Manages item/category definitions and inventory operations.
+ *
+ * No constructor args — compatible with tsyringe `{ useClass }` DI resolution.
+ * Projects can extend this class and override any method via the plugin system.
+ */
+export class InventoryManager {
+  private categories = new Map<string, VylosCategory>();
+  private items = new Map<string, VylosItem>();
+
+  // --- Category registry ---
+
+  registerCategory(cat: VylosCategory): void {
+    this.categories.set(cat.id, cat);
+  }
+
+  registerCategories(cats: VylosCategory[]): void {
+    for (const cat of cats) {
+      this.registerCategory(cat);
+    }
+  }
+
+  getCategory(id: string): VylosCategory | undefined {
+    return this.categories.get(id);
+  }
+
+  /** Returns all categories sorted by sortOrder (ascending, undefined last) */
+  getCategories(): VylosCategory[] {
+    return [...this.categories.values()].sort((a, b) => {
+      const sa = a.sortOrder ?? Infinity;
+      const sb = b.sortOrder ?? Infinity;
+      return sa - sb;
+    });
+  }
+
+  // --- Item registry ---
+
+  registerItem(item: VylosItem): void {
+    this.items.set(item.id, item);
+  }
+
+  registerItems(items: VylosItem[]): void {
+    for (const item of items) {
+      this.registerItem(item);
+    }
+  }
+
+  getItem(id: string): VylosItem | undefined {
+    return this.items.get(id);
+  }
+
+  getItemsByCategory(categoryId: string): VylosItem[] {
+    return [...this.items.values()].filter((i) => i.category === categoryId);
+  }
+
+  // --- Inventory operations (on state.inventories) ---
+
+  /**
+   * Add items to a bag. Auto-creates bag if missing.
+   * Respects maxStack from the item definition.
+   * @returns actual quantity added
+   */
+  add(inv: InventoryData, bag: string, itemId: string, qty = 1): number {
+    if (qty <= 0) return 0;
+
+    if (!inv[bag]) inv[bag] = {};
+
+    const current = inv[bag][itemId] ?? 0;
+    const item = this.items.get(itemId);
+    const maxStack = item?.maxStack ?? Infinity;
+
+    // Check maxSlots: if the item isn't already in the bag and we'd exceed slot count
+    if (current === 0 && item) {
+      const category = this.categories.get(item.category);
+      if (category?.maxSlots !== undefined) {
+        const slotCount = Object.keys(inv[bag]).length;
+        if (slotCount >= category.maxSlots) return 0;
+      }
+    }
+
+    const actual = Math.min(qty, maxStack - current);
+    if (actual <= 0) return 0;
+
+    inv[bag][itemId] = current + actual;
+    return actual;
+  }
+
+  /**
+   * Remove items from a bag. Cleans up zero entries.
+   * @returns actual quantity removed
+   */
+  remove(inv: InventoryData, bag: string, itemId: string, qty = 1): number {
+    if (qty <= 0) return 0;
+    if (!inv[bag]) return 0;
+
+    const current = inv[bag][itemId] ?? 0;
+    if (current <= 0) return 0;
+
+    const actual = Math.min(qty, current);
+    const remaining = current - actual;
+
+    if (remaining <= 0) {
+      delete inv[bag][itemId];
+    } else {
+      inv[bag][itemId] = remaining;
+    }
+
+    return actual;
+  }
+
+  /** Get the quantity of an item in a bag */
+  count(inv: InventoryData, bag: string, itemId: string): number {
+    return inv[bag]?.[itemId] ?? 0;
+  }
+
+  /** Check if a bag has at least `qty` of an item */
+  has(inv: InventoryData, bag: string, itemId: string, qty = 1): boolean {
+    return this.count(inv, bag, itemId) >= qty;
+  }
+
+  /** Check if a bag has all the specified items in required quantities */
+  hasAll(inv: InventoryData, bag: string, items: Record<string, number>): boolean {
+    for (const [itemId, qty] of Object.entries(items)) {
+      if (!this.has(inv, bag, itemId, qty)) return false;
+    }
+    return true;
+  }
+
+  /** List all items in a bag as [itemId, quantity] pairs */
+  list(inv: InventoryData, bag: string): Array<[string, number]> {
+    if (!inv[bag]) return [];
+    return Object.entries(inv[bag]);
+  }
+
+  /** Clear all items from a bag */
+  clearBag(inv: InventoryData, bag: string): void {
+    delete inv[bag];
+  }
+
+  // --- Cleanup ---
+
+  /** Clear all registered categories and items */
+  clear(): void {
+    this.categories.clear();
+    this.items.clear();
+  }
+}

package/src/engine/managers/LocationManager.ts

@@ -1,4 +1,4 @@
-import type { VylosLocation, LocationLink, BaseGameState, BackgroundEntry } from '../types';
+import type { VylosLocation, LocationLink, VylosGameState, BackgroundEntry } from '../types';
 import { resolveBackground } from '../utils/TimeHelper';
 import { logger } from '../utils/logger';
 
@@ -38,7 +38,7 @@ export class LocationManager {
   }
 
   /** Get locations accessible from a given location, considering state conditions */
-  getAccessibleFrom(locationId: string, state: BaseGameState): VylosLocation[] {
+  getAccessibleFrom(locationId: string, state: VylosGameState): VylosLocation[] {
     const linkedIds = this.links
       .filter(link => {
         if (link.from !== locationId) return false;

package/src/engine/types/actions.ts

@@ -1,8 +1,8 @@
-import type { BaseGameState } from './game-state';
+import type { VylosGameState } from './game-state';
 import type { TextEntry } from './events';
 
 /** An action available to the player at a location */
-export interface VylosAction<TState extends BaseGameState = BaseGameState> {
+export interface VylosAction<TState extends VylosGameState = VylosGameState> {
   /** Unique action ID */
   id: string;
 

package/src/engine/types/checkpoint.ts

@@ -1,4 +1,4 @@
-import type { BaseGameState } from './game-state';
+import type { VylosGameState } from './game-state';
 import type { DialogueState, ChoiceOption } from './engine';
 
 /** A checkpoint captured at each interaction point */
@@ -6,7 +6,7 @@ export interface Checkpoint {
   /** Sequential step number within the event */
   step: number;
   /** Deep clone of game state at this point */
-  gameState: BaseGameState;
+  gameState: VylosGameState;
   /** Type of interaction at this step */
   type: CheckpointType;
   /** Stored choice result (for replay during rollback) */

package/src/engine/types/dialogue.ts

@@ -1,14 +1,7 @@
 import type { TextEntry } from './events';
 
-/** Resolved dialogue line ready for display */
-export interface DialogueLine {
-  text: string;
-  speaker: string | null;
-  isNarration: boolean;
-}
-
-/** Character definition for speaker resolution */
-export interface Character {
+/** Base character — projects extend this into their own Character */
+export interface VylosCharacter {
   id: string;
   name: string | TextEntry;
   color?: string;

package/src/engine/types/engine.ts

@@ -1,4 +1,5 @@
 import type { DrawableEventEntry } from './events';
+import type { VylosCharacter } from './dialogue';
 
 /** Engine lifecycle phases */
 export enum EnginePhase {
@@ -32,7 +33,7 @@ export interface EngineState {
 
 export interface DialogueState {
   text: string;
-  speaker: string | null;
+  speaker: VylosCharacter | null;
   isNarration: boolean;
 }