(cam: Phaser.Cameras.Scene2D.Camera)

()

()

()

(cam: Phaser.Cameras.Scene2D.Camera)

(server: HttpServer, ctx: AppContext)

(value)

( tick: number, config?: SceneTimeConfig, )

(gameTime: GameTime)

(text: string)

(arr: T[])

(path: GridPoint[])

()

(active: boolean)

(active: boolean)

(ms)

(ms)

(ms: number)

(ms)

(x, y, collisionData, gridWidth, gridHeight, tileSize)

(x, y, box, collisionData, gridWidth, gridHeight, tileSize)

(params: { prompt: string; sizeK: 1 | 2 | 4; keepArtifacts?: boolean })

(characters: InitFrameCharacter[])

(timelineId: string)

()

()

( status: "done" | "active" | "pending" | "error", )

( status: "done" | "active" | "pending" | "error", )

(disabled: boolean)

()

(input: string)

(text)

(text: string)

(event: SimulationEvent)

(timelineId: string)

(active: boolean)

(charId: string, currentTime: GameTime)

(text: string)

(period: string)

(type: string)

(type: string)

(type: string)

(now: number)

( current: { valence: number; arousal: number }, event: { valence: number; intensity: number }, )

(objectId: string, newState: string, description?: string)

()

(timeoutMs)

(path: { x: number; y: number }[], onComplete?: () => void)

(message: string, worldId: string | null)

(env: EnvMap)

({ worldDir, design, width, height })

(world_dir: Path, design: dict, chars_dir: Path)

()

({ eventBus }: { eventBus: Phaser.Events.EventEmitter })

({ eventBus }: { eventBus: Phaser.Events.EventEmitter })

({ charId, followedCharId, onToggleFollow, characters, liveEvents, }: { charId: string; followed

({ intensity = "calm" }: { intensity?: Intensity })

({ hasExistingWorlds, }: { hasExistingWorlds: boolean; })

({ events, ticksPerScene, onDismiss, }: { events: SimulationEvent[]; ticksPerScene: number; onDism

()

({ events }: { events: SimulationEvent[] })

({ onClose }: { onClose: () => void })

({ prompt, setPrompt, sizeK, setSizeK, submitting, submitError, conflictJobId, onSubmit, onA

({ style }: { style?: CSSProperties })

({ eventBus, presentationMode = false, }: { eventBus: Phaser.Events.EventEmitter; presentationMode?: b

({ onClose }: { onClose: () => void })

({ draft, onChange, onSave, onCancel, busy, flash, }: { draft: Record<string, string>; onChang

({ mode, snapshot, events, logsOpen, setLogsOpen, logBoxRef, sizeK, onRetry, onCancelJob,

({ onClose }: { onClose: () => void })

({ day, phase, title, timeString, periodLabel, variant = "open", onCovered, onComplete, }: {

({ selectedCharId, followedCharId, onSelect, onToggleFollow, events, }: { selectedCharId: string |

()

({ onClose }: { onClose: () => void })

({ worldInfo, gameTime, isDevMode, onToggleDevMode, showWalkableOverlay, showRegionBoundsOverlay,

({ worldKey, worldName, worldDescription, hasRun, topOffset, }: { worldKey: string; worldName: s

({ children, onClick, title }: { children: React.ReactNode; onClick: () => void; title?: string })

(charId: string, gameDay: number, content: string)

(events: SimulationEvent[])

(objectId: string, characterId: string)

(event: SimulationEvent)

(events: SimulationEvent[])

(params: { participants: { profile: CharacterProfile; state: CharacterState; memoriesAbo

(params: { profile: CharacterProfile; todayMemories: string; gameDay: number; })

(jobId: string)

(messages, opts = {})

(a: GameTime, b: GameTime)

(a: HistoryRecord, b: HistoryRecord)

(error: Error, info: ErrorInfo)

()

()

( scene: Phaser.Scene, mapWidth: number, mapHeight: number, initialCenter?: { x: number; y: nu

(private globalEventBus: Phaser.Events.EventEmitter)

( private mapManager: MapManager, private pathfinder: PathfindingManager, private sprites: Map<str

(mapManager: MapManager)

( scene: Phaser.Scene, x: number, y: number, config: { characterId: string; name:

(message: string, activeJobId: string)

(config?: LLMConfig)

(private worldManager: WorldManager)

(public readonly activeJobId: string)

(weights?: Partial<RetrievalWeights>)