clibuddy 1.0.0

package/dist/adventure/templates.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNarrativeText = generateNarrativeText;
+exports.generateNarrativeTitle = generateNarrativeTitle;
+exports.generateChoiceLabels = generateChoiceLabels;
+exports.generateCombatText = generateCombatText;
+exports.generateCombatTitle = generateCombatTitle;
+exports.generateTreasureText = generateTreasureText;
+exports.generateRestText = generateRestText;
+exports.generateEvent = generateEvent;
+exports.generateBuddyLine = generateBuddyLine;
+exports.generateBossText = generateBossText;
+exports.generateHiddenRoomText = generateHiddenRoomText;
+function pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+// ─── Narrative Room Templates ────────────────────────────────
+function generateNarrativeText(biome) {
+    const templates = [
+        [`The ${pick(biome.adjectives)} ${pick(biome.nouns)} stretches before you.`, `Two paths diverge ahead — ${pick(biome.directions)} and ${pick(biome.directions)}.`],
+        [`You reach a ${pick(biome.landmarks)}. The air feels ${pick(biome.adjectives)}.`, `Something rustles in ${pick(biome.hidingSpots)}.`],
+        [`The path narrows as you enter a ${pick(biome.adjectives)} ${pick(biome.nouns)}.`, `You can go ${pick(biome.directions)} or ${pick(biome.directions)}.`],
+        [`A ${pick(biome.landmarks)} marks a crossroads.`, `The ${pick(biome.nouns)} feels ${pick(biome.adjectives)} here.`],
+        [`Your footsteps echo in the ${pick(biome.adjectives)} ${pick(biome.nouns)}.`, `Ahead, the path splits around a ${pick(biome.landmarks)}.`],
+        [`The ${pick(biome.nouns)} opens up to reveal a ${pick(biome.landmarks)}.`, `The air is ${pick(biome.adjectives)}. Which way?`],
+        [`Deeper into the ${pick(biome.nouns)}, you hear sounds from ${pick(biome.hidingSpots)}.`, `The path branches — ${pick(biome.directions)} looks safe, ${pick(biome.directions)} looks... interesting.`],
+        [`You stand at the edge of a ${pick(biome.adjectives)} ${pick(biome.nouns)}.`, `A ${pick(biome.landmarks)} marks two possible routes.`],
+        [`Shadows dance across a ${pick(biome.landmarks)}.`, `The ${pick(biome.nouns)} seems to whisper. Two paths await.`],
+    ];
+    return pick(templates);
+}
+function generateNarrativeTitle(biome) {
+    const titles = [
+        `The ${capitalize(pick(biome.adjectives))} ${capitalize(pick(biome.nouns))}`,
+        `${capitalize(pick(biome.landmarks))}`,
+        `A Fork in the ${capitalize(pick(biome.nouns))}`,
+        `The ${capitalize(pick(biome.adjectives))} Path`,
+    ];
+    return pick(titles);
+}
+function generateChoiceLabels(biome) {
+    return [
+        `Go ${pick(biome.directions)}`,
+        `Head ${pick(biome.directions)}`,
+    ];
+}
+// ─── Combat Room Templates ───────────────────────────────────
+function generateCombatText(biome, enemyName) {
+    const templates = [
+        [`A ${enemyName} leaps out from ${pick(biome.hidingSpots)}!`],
+        [`You stumble into a ${pick(biome.adjectives)} clearing. A ${enemyName} blocks the way!`],
+        [`Something moves in ${pick(biome.hidingSpots)}... it's a ${enemyName}!`],
+        [`The ${pick(biome.nouns)} grows ${pick(biome.adjectives)}. A ${enemyName} appears!`],
+    ];
+    return pick(templates);
+}
+function generateCombatTitle(biome) {
+    return `${capitalize(pick(biome.adjectives))} Encounter`;
+}
+// ─── Treasure Room Templates ─────────────────────────────────
+function generateTreasureText(biome) {
+    const templates = [
+        [`Behind a ${pick(biome.landmarks)}, something glints...`],
+        [`Your buddy digs near ${pick(biome.hidingSpots)} and finds something!`],
+        [`Hidden in the ${pick(biome.adjectives)} ${pick(biome.nouns)}, a stash awaits!`],
+        [`A ${pick(biome.landmarks)} conceals a small cache of treasure.`],
+    ];
+    return pick(templates);
+}
+// ─── Rest Room Templates ─────────────────────────────────────
+function generateRestText(biome) {
+    const templates = [
+        [`A peaceful spot near a ${pick(biome.landmarks)}. The ${pick(biome.nouns)} is quiet here.`],
+        [`A sheltered ${pick(biome.nouns)} offers respite. You could rest here...`],
+        [`The ${pick(biome.adjectives)} atmosphere fades. This feels safe.`],
+    ];
+    return pick(templates);
+}
+function generateEvent(biome) {
+    const events = [
+        {
+            text: [`A small creature peeks out from ${pick(biome.hidingSpots)}.`, `It seems to want to trade...`],
+            choices: [
+                { label: "Offer a Berry", outcome: "It hands you something shiny in return!", effect: { itemGain: pick(biome.loot.uncommon) } },
+                { label: "Wave and move on", outcome: "The creature waves goodbye." },
+            ],
+        },
+        {
+            text: [`You find a strange ${pick(biome.adjectives)} chest near a ${pick(biome.landmarks)}.`, `It could be a trap... or treasure.`],
+            choices: [
+                { label: "Open it carefully", outcome: "Inside — a useful item!", effect: { itemGain: pick(biome.loot.rare) } },
+                { label: "Leave it alone", outcome: "Better safe than sorry. You move on." },
+                { label: "Kick it open", outcome: "A puff of gas! You feel woozy.", effect: { hp: -10 } },
+            ],
+        },
+        {
+            text: [`A warm glow emanates from a ${pick(biome.landmarks)}.`, `It feels... magical.`],
+            choices: [
+                { label: "Touch the glow", outcome: "A warm feeling washes over you!", effect: { hp: 15, happiness: 5 } },
+                { label: "Back away cautiously", outcome: "The glow fades. Nothing happens." },
+            ],
+        },
+        {
+            text: [`A weary traveler rests by the path.`, `"Care to share some food? I'll make it worth your while."`],
+            choices: [
+                { label: "Share some food", outcome: "\"Thank you! Take this.\"", effect: { itemGain: pick(biome.loot.uncommon) } },
+                { label: "Apologize and decline", outcome: "The traveler nods and rests." },
+            ],
+        },
+        {
+            text: [`A wise-looking creature sits near a ${pick(biome.landmarks)}.`, `"Answer my riddle and I'll reward you!"`],
+            choices: [
+                { label: "Accept the riddle", outcome: "You answer wisely! A reward appears.", effect: { itemGain: pick(biome.loot.rare) } },
+                { label: "Politely refuse", outcome: "The creature nods knowingly." },
+            ],
+        },
+        {
+            text: [`A small animal is trapped under a ${pick(biome.adjectives)} rock near ${pick(biome.hidingSpots)}.`, `It whimpers for help...`],
+            choices: [
+                { label: "Help free it", outcome: "It scurries free! It drops something as thanks.", effect: { itemGain: pick(biome.loot.uncommon), happiness: 5 } },
+                { label: "It might be a trap...", outcome: "You move on cautiously." },
+            ],
+        },
+        {
+            text: [`A glowing rune is etched into a ${pick(biome.landmarks)}.`, `It pulses with ${pick(biome.adjectives)} energy.`],
+            choices: [
+                { label: "Touch the rune", outcome: "Power surges through you!", effect: { hp: 20 } },
+                { label: "Study it from afar", outcome: "You learn something, but feel nothing change." },
+                { label: "Smash it", outcome: "The rune explodes! Ow!", effect: { hp: -15 } },
+            ],
+        },
+        {
+            text: [`Someone left a campfire burning near ${pick(biome.hidingSpots)}.`, `There's a pack nearby...`],
+            choices: [
+                { label: "Warm up and rest", outcome: "The warmth is soothing.", effect: { hp: 10, happiness: 5 } },
+                { label: "Search the pack", outcome: "You find something useful!", effect: { itemGain: pick(biome.loot.uncommon) } },
+                { label: "Leave it — not yours", outcome: "You move on with a clear conscience." },
+            ],
+        },
+    ];
+    return pick(events);
+}
+// ─── Buddy Dialogue Templates ────────────────────────────────
+const SPECIES_ADVENTURE_LINES = {
+    rabbit: [
+        "My ears are twitching... something's nearby!", "I can hop right over this!",
+        "This place smells like carrots... no wait, danger.", "Want me to scout ahead? I'm fast!",
+        "*nose wiggles* I sense trouble...", "I could dig us an escape route!",
+        "My lucky foot says... this way!",
+    ],
+    cat: [
+        "I sense prey ahead.", "*sniffs the air* Interesting...", "I'll lead. Stay behind me.",
+        "*tail flicks* Something moved.", "I've hunted worse than this.",
+        "Do NOT touch me right now. I'm focused.", "This reminds me of my afternoon prowl.",
+    ],
+    frog: [
+        "Ribbit! I mean... let's go!", "The moisture here is nice.", "*tongue flick* Just checking.",
+        "I can sense vibrations... something big!", "Hop hop hop! Keep up!",
+        "If it gets wet, that's MY territory.", "My skin is tingling... that's either danger or humidity.",
+    ],
+    owl: [
+        "I can see far ahead from here.", "Hoo goes there?", "Knowledge awaits in every corner.",
+        "I've read about places like this...", "*head rotates* Scanning for threats.",
+        "Logically, the left path is safer.", "My wisdom says proceed with caution.",
+    ],
+    fox: [
+        "I smell adventure!", "My instincts say... this way!", "Stay sharp, I'll sniff out danger.",
+        "There's a shortcut here, I can feel it!", "Trust the nose!",
+        "*tail swish* I've got a plan.", "Foxes always find the best paths.",
+    ],
+    phoenix: [
+        "My flames light the way!", "*feathers glow* I feel strong here.", "Even if we fall, we rise again!",
+        "The fire within me burns brighter here!", "Nothing can stop eternal flame!",
+        "I sense ancient power nearby...", "*sparks fly from wings* Let's GO!",
+    ],
+    dragon: [
+        "I smell treasure nearby!", "*tiny roar* I'm not scared!", "My scales will protect us!",
+        "Is that gold? I think I smell gold!", "*puffs smoke confidently*",
+        "I'm basically a fortress. With legs.", "Anything that glows is mine. That's the rule.",
+    ],
+};
+const GENERIC_BUDDY_LINES = [
+    "Which way should we go?",
+    "This looks interesting...",
+    "Stay close!",
+    "I've got a good feeling about this!",
+    "Let's be careful here...",
+    "Ooh, what's over there?",
+    "I wonder what we'll find!",
+    "This is exciting!",
+    "I trust your instincts!",
+    "Lead the way, I've got your back!",
+    "Something tells me this will be worth it.",
+];
+function generateBuddyLine(speciesId, biome) {
+    // 50% species-specific, 50% generic
+    if (Math.random() < 0.5) {
+        const speciesLines = SPECIES_ADVENTURE_LINES[speciesId];
+        if (speciesLines)
+            return pick(speciesLines);
+    }
+    // Comfort bonus line
+    if (biome.comfortSpecies.includes(speciesId) && Math.random() < 0.3) {
+        return "I feel right at home here!";
+    }
+    return pick(GENERIC_BUDDY_LINES);
+}
+// ─── Boss Room Templates ─────────────────────────────────────
+function generateBossText(biome, bossName) {
+    const templates = [
+        [`The ${pick(biome.nouns)} trembles. Something massive approaches...`, `${bossName} emerges!`],
+        [`A deafening sound echoes through the ${pick(biome.nouns)}.`, `${bossName} blocks your path — there's no going back!`],
+        [`The air grows heavy. ${bossName} rises from ${pick(biome.hidingSpots)}!`],
+    ];
+    return pick(templates);
+}
+// ─── Hidden Room Templates ───────────────────────────────────
+function generateHiddenRoomText(biome, speciesId) {
+    const speciesName = speciesId.charAt(0).toUpperCase() + speciesId.slice(1);
+    return [
+        `Your ${speciesName} senses notice something others would miss...`,
+        `A hidden passage reveals itself in the ${pick(biome.adjectives)} ${pick(biome.nouns)}!`,
+    ];
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//# sourceMappingURL=templates.js.map

package/dist/adventure/types.d.ts

@@ -0,0 +1,236 @@
+export type Element = "fire" | "water" | "nature" | "light" | "shadow" | "neutral";
+export declare function getElementMultiplier(atkElement: Element, defElement: Element): {
+    multiplier: number;
+    label: string;
+};
+export declare const ELEMENT_ICONS: Record<Element, string>;
+export declare const SPECIES_ELEMENTS: Record<string, Element>;
+export interface CombatStats {
+    maxHp: number;
+    hp: number;
+    atk: number;
+    def: number;
+    spd: number;
+    dodgeChance: number;
+}
+export type AIBehavior = "aggressive" | "defensive" | "tactical" | "berserker" | "evasive";
+export interface EnemyDef {
+    id: string;
+    name: string;
+    element: Element;
+    aiBehavior: AIBehavior;
+    art: string[];
+    encounterLine: string;
+    attackLine: string;
+    defeatLine: string;
+    defendLine?: string;
+    baseHp: number;
+    baseAtk: number;
+    baseDef: number;
+    baseSpd: number;
+    baseDodge?: number;
+    xpReward: number;
+    dropChance: number;
+    dropPool: string[];
+    isBoss?: boolean;
+    specialMove?: {
+        name: string;
+        line: string;
+        damageMultiplier: number;
+        chance: number;
+    };
+    /** Boss phase 2 special (triggers at HP < 50%) */
+    phase2Move?: {
+        name: string;
+        line: string;
+        damageMultiplier: number;
+        chance: number;
+    };
+    /** Boss enrage at HP < 25%: +atkBonus% ATK, uses special every other turn */
+    enrageAtkBonus?: number;
+}
+export type SkillEffect = {
+    type: "damage";
+    multiplier: number;
+    ignoreDefense?: boolean;
+} | {
+    type: "buff";
+    stat: "atk" | "def" | "dodge" | "crit";
+    amount: number;
+    turns: number;
+} | {
+    type: "debuff";
+    stat: "atk" | "def";
+    amount: number;
+    turns: number;
+} | {
+    type: "poison";
+    damagePerTurn: number;
+    turns: number;
+} | {
+    type: "stun";
+    turns: number;
+} | {
+    type: "revive";
+    hpPercent: number;
+} | {
+    type: "skip_enemy_turn";
+};
+export interface SkillDef {
+    id: string;
+    name: string;
+    description: string;
+    speciesId: string;
+    levelRequired: number;
+    energyCost: number;
+    element?: Element;
+    effect: SkillEffect;
+    useLine: string;
+}
+export type RoomType = "narrative" | "combat" | "treasure" | "rest" | "event" | "boss";
+export interface RoomChoice {
+    label: string;
+    nextRoomId: string;
+}
+export interface RoomCondition {
+    type: "species" | "level" | "item";
+    value: string | number;
+}
+export interface RoomDef {
+    id: string;
+    type: RoomType;
+    title: string;
+    text: string[];
+    buddyLine: string;
+    nextRoomId?: string;
+    choices?: RoomChoice[];
+    enemyId?: string;
+    lootPool?: string[];
+    healAmount?: number;
+    condition?: RoomCondition;
+    npcsPresent?: string[];
+    eventChoices?: {
+        label: string;
+        outcome: string;
+        nextRoomId?: string;
+        effect?: Partial<{
+            hp: number;
+            hunger: number;
+            happiness: number;
+            itemGain: string;
+        }>;
+    }[];
+}
+export interface AdventureDef {
+    id: string;
+    name: string;
+    description: string;
+    difficulty: "easy" | "medium" | "hard" | "boss" | number;
+    levelRequired: number;
+    energyCost: number;
+    hungerCost: number;
+    rooms: RoomDef[];
+    roomMap: Map<string, RoomDef>;
+    startRoomId: string;
+    completionXp: number;
+    isScene?: boolean;
+    hideRoomCounter?: boolean;
+}
+export type StatType = "atk" | "def" | "crit" | "dodge" | "spd" | "stun" | "poison";
+export interface StatusEffect {
+    stat: StatType;
+    amount: number;
+    turnsLeft: number;
+}
+export type StatusCondition = {
+    type: "burn";
+    damagePerTurn: number;
+    turnsLeft: number;
+} | {
+    type: "poison";
+    damagePerTurn: number;
+    turnsLeft: number;
+} | {
+    type: "freeze";
+    turnsLeft: number;
+} | {
+    type: "stun";
+    turnsLeft: number;
+} | {
+    type: "charm";
+    turnsLeft: number;
+} | {
+    type: "blind";
+    turnsLeft: number;
+} | {
+    type: "regen";
+    healPerTurn: number;
+    turnsLeft: number;
+} | {
+    type: "shield";
+    amount: number;
+} | {
+    type: "buff";
+    stat: StatType;
+    amount: number;
+    turnsLeft: number;
+} | {
+    type: "debuff";
+    stat: StatType;
+    amount: number;
+    turnsLeft: number;
+};
+/** Elements immune to certain conditions */
+export declare const CONDITION_IMMUNITIES: Record<string, Element[]>;
+/** Check if an element is immune to a condition type */
+export declare function isImmune(conditionType: string, element: Element): boolean;
+export interface CombatState {
+    phase: "player_turn" | "player_animate" | "enemy_turn" | "enemy_animate" | "victory" | "defeat" | "fled";
+    playerStats: CombatStats;
+    enemyStats: CombatStats;
+    enemy: EnemyDef;
+    combatEnergy: number;
+    maxCombatEnergy: number;
+    playerEffects: StatusEffect[];
+    enemyEffects: StatusEffect[];
+    playerConditions: StatusCondition[];
+    enemyConditions: StatusCondition[];
+    isDefending: boolean;
+    turnCount: number;
+    log: string[];
+    ticksInPhase: number;
+    damageTakenThisBattle: number;
+    usedRevive: boolean;
+    morale: number;
+    playerElement: Element;
+    enemyElement: Element;
+    equippedGearIds: string[];
+    lastSkillUsed?: string;
+    comboTriggeredThisBattle: number;
+}
+export interface AdventureState {
+    active: boolean;
+    adventureId: string;
+    currentRoomId: string;
+    roomsVisited: string[];
+    phase: "room" | "combat" | "result";
+    combat?: CombatState;
+    morale: number;
+    textPage: number;
+    textFullyShown: boolean;
+    lootCollected: string[];
+    xpEarned: number;
+    battlesWon: number;
+    battlesLost: number;
+    battlesFled: number;
+    damageTaken: number;
+    buddyReaction: string;
+}
+export declare function createInactiveAdventure(): AdventureState;
+/** Build a roomMap from a rooms array for fast ID lookup */
+export declare function buildRoomMap(rooms: RoomDef[]): Map<string, RoomDef>;
+/** Get a room by ID from an adventure */
+export declare function getRoom(adventure: AdventureDef, roomId: string): RoomDef | undefined;
+/** Get room index for display purposes (how many rooms visited) */
+export declare function getRoomProgress(state: AdventureState): number;
+//# sourceMappingURL=types.d.ts.map

package/dist/adventure/types.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONDITION_IMMUNITIES = exports.SPECIES_ELEMENTS = exports.ELEMENT_ICONS = void 0;
+exports.getElementMultiplier = getElementMultiplier;
+exports.isImmune = isImmune;
+exports.createInactiveAdventure = createInactiveAdventure;
+exports.buildRoomMap = buildRoomMap;
+exports.getRoom = getRoom;
+exports.getRoomProgress = getRoomProgress;
+// Fire > Nature > Water > Fire, Light <> Shadow
+const ELEMENT_CHART = {
+    fire: ["nature"],
+    water: ["fire"],
+    nature: ["water"],
+    light: ["shadow"],
+    shadow: ["light"],
+    neutral: [],
+};
+const ELEMENT_WEAK = {
+    fire: ["water"],
+    water: ["nature"],
+    nature: ["fire"],
+    light: ["shadow"],
+    shadow: ["light"],
+    neutral: [],
+};
+function getElementMultiplier(atkElement, defElement) {
+    if (atkElement === "neutral" || defElement === "neutral")
+        return { multiplier: 1.0, label: "" };
+    if (ELEMENT_CHART[atkElement]?.includes(defElement))
+        return { multiplier: 1.5, label: "Super effective!" };
+    if (ELEMENT_WEAK[atkElement]?.includes(defElement))
+        return { multiplier: 0.6, label: "Not very effective..." };
+    return { multiplier: 1.0, label: "" };
+}
+exports.ELEMENT_ICONS = {
+    fire: "🔥",
+    water: "💧",
+    nature: "🌿",
+    light: "✨",
+    shadow: "🌑",
+    neutral: "⚪",
+};
+exports.SPECIES_ELEMENTS = {
+    rabbit: "nature",
+    cat: "shadow",
+    frog: "water",
+    owl: "light",
+    fox: "nature",
+    phoenix: "fire",
+    dragon: "fire",
+};
+/** Elements immune to certain conditions */
+exports.CONDITION_IMMUNITIES = {
+    burn: ["fire"],
+    freeze: ["water"],
+};
+/** Check if an element is immune to a condition type */
+function isImmune(conditionType, element) {
+    return exports.CONDITION_IMMUNITIES[conditionType]?.includes(element) ?? false;
+}
+function createInactiveAdventure() {
+    return {
+        active: false,
+        adventureId: "",
+        currentRoomId: "",
+        roomsVisited: [],
+        phase: "room",
+        morale: 50,
+        textPage: 0,
+        textFullyShown: false,
+        lootCollected: [],
+        xpEarned: 0,
+        battlesWon: 0,
+        battlesLost: 0,
+        battlesFled: 0,
+        damageTaken: 0,
+        buddyReaction: "",
+    };
+}
+/** Build a roomMap from a rooms array for fast ID lookup */
+function buildRoomMap(rooms) {
+    const map = new Map();
+    for (const room of rooms) {
+        map.set(room.id, room);
+    }
+    return map;
+}
+/** Get a room by ID from an adventure */
+function getRoom(adventure, roomId) {
+    return adventure.roomMap.get(roomId);
+}
+/** Get room index for display purposes (how many rooms visited) */
+function getRoomProgress(state) {
+    return state.roomsVisited.length;
+}
+//# sourceMappingURL=types.js.map

package/dist/app/state.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Centralized app state — all mutable state lives here.
+ * Accessed and mutated from index.ts handlers.
+ * This consolidates the 29 global `let` variables into one object.
+ */
+import { BuddyState } from "../buddy/types";
+import { AdventureDef, AdventureState } from "../adventure/types";
+import { ActiveEvent } from "../events/engine";
+import { InventoryUIState } from "../rendering/inventoryUI";
+import { OverlayState } from "../rendering/overlayUI";
+import { MinigameMenuState } from "../rendering/minigameUI";
+import { AdventureMenuState } from "../adventure/adventureUI";
+import { MiniGameState } from "../minigames/types";
+import { PaletteState } from "../rendering/commandPalette";
+import { Screen } from "../rendering/screen";
+export interface AppState {
+    screen: Screen;
+    buddyState: BuddyState | null;
+    appPhase: "roll-wait" | "rolling" | "reveal" | "naming" | "playing";
+    animFrame: number;
+    animTimer: ReturnType<typeof setInterval> | null;
+    decayTimer: ReturnType<typeof setInterval> | null;
+    feedbackMessage: string | undefined;
+    feedbackTimeout: ReturnType<typeof setTimeout> | null;
+    dialogueMessage: string | undefined;
+    dialogueSource: string | undefined;
+    dialogueTimeout: ReturnType<typeof setTimeout> | null;
+    dialogueTick: number;
+    activeEvent: ActiveEvent | null;
+    petSequence: string[] | null;
+    petTick: number;
+    inventoryUI: InventoryUIState;
+    overlay: OverlayState;
+    minigameMenu: MinigameMenuState;
+    adventureMenu: AdventureMenuState;
+    palette: PaletteState;
+    activeMiniGame: MiniGameState;
+    activeAdventure: AdventureState;
+    currentAdventureDef: AdventureDef | null;
+    endlessDepth: number;
+    isEndlessMode: boolean;
+    showingSkillMenu: boolean;
+    inputBuffer: string;
+    pendingCommand: string | null;
+    argsBuffer: string;
+    nameBuffer: string;
+}
+export declare function createInitialState(): AppState;
+//# sourceMappingURL=state.d.ts.map

package/dist/app/state.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Centralized app state — all mutable state lives here.
+ * Accessed and mutated from index.ts handlers.
+ * This consolidates the 29 global `let` variables into one object.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialState = createInitialState;
+const types_1 = require("../adventure/types");
+const inventoryUI_1 = require("../rendering/inventoryUI");
+const overlayUI_1 = require("../rendering/overlayUI");
+const minigameUI_1 = require("../rendering/minigameUI");
+const adventureUI_1 = require("../adventure/adventureUI");
+const types_2 = require("../minigames/types");
+const commandPalette_1 = require("../rendering/commandPalette");
+const screen_1 = require("../rendering/screen");
+function createInitialState() {
+    return {
+        screen: new screen_1.Screen(),
+        buddyState: null,
+        appPhase: "roll-wait",
+        animFrame: 0,
+        animTimer: null,
+        decayTimer: null,
+        feedbackMessage: undefined,
+        feedbackTimeout: null,
+        dialogueMessage: undefined,
+        dialogueSource: undefined,
+        dialogueTimeout: null,
+        dialogueTick: 0,
+        activeEvent: null,
+        petSequence: null,
+        petTick: 0,
+        inventoryUI: (0, inventoryUI_1.createInventoryUI)(),
+        overlay: (0, overlayUI_1.createOverlay)(),
+        minigameMenu: (0, minigameUI_1.createMinigameMenu)(),
+        adventureMenu: (0, adventureUI_1.createAdventureMenu)(),
+        palette: (0, commandPalette_1.createPalette)(),
+        activeMiniGame: (0, types_2.createInactiveGame)(),
+        activeAdventure: (0, types_1.createInactiveAdventure)(),
+        currentAdventureDef: null,
+        endlessDepth: 0,
+        isEndlessMode: false,
+        showingSkillMenu: false,
+        inputBuffer: "",
+        pendingCommand: null,
+        argsBuffer: "",
+        nameBuffer: "",
+    };
+}
+//# sourceMappingURL=state.js.map

package/dist/buddy/activities.d.ts

@@ -0,0 +1,16 @@
+import { ActivityType, ActivityState, BuddyState, BuddyStats } from "./types";
+/** Build an ActivityState for the given activity type based on current stats */
+/** Build an ActivityState. Pass statOverrides to use custom stat deltas (e.g. from inventory items). */
+export declare function startActivity(state: BuddyState, type: Exclude<ActivityType, "idle">, statOverrides?: Partial<BuddyStats>): ActivityState;
+/**
+ * Apply activity progress using linear interpolation.
+ * Returns updated state. Clears activity and awards XP when complete.
+ */
+export declare function applyActivityProgress(state: BuddyState): BuddyState;
+/** Check if the current activity blocks a new action */
+export declare function isActivityBlocked(currentActivity: ActivityType | undefined, attempted: Exclude<ActivityType, "idle">): boolean;
+/** Returns seconds remaining for the current activity */
+export declare function activityTimeRemaining(activity: ActivityState): number;
+/** Format remaining time as "1:42" or "8s" */
+export declare function formatTimeRemaining(activity: ActivityState): string;
+//# sourceMappingURL=activities.d.ts.map