@jcendal/opencode-digital-pet 0.2.0-dev.0

package/dist/digital-pet-animation/constants/evolution-battle.d.ts

@@ -0,0 +1,5 @@
+export declare const EVOLUTION_BATTLE_HITS_TO_WIN = 3;
+export declare const EVOLUTION_BATTLE_MAX_SHOTS = 24;
+export declare const BATTLE_GAP_COLUMNS = 12;
+export declare const BATTLE_SCORE_HIT_PIP = "\u2588";
+export declare const BATTLE_SCORE_MISS_PIP = "\u2591";

package/dist/digital-pet-animation/constants/monster-artwork.d.ts

@@ -0,0 +1,4 @@
+/** Rows in a single monster ASCII frame (Digimon sprite sheet cell). */
+export declare const MONSTER_FRAME_ROWS = 8;
+/** Columns in a single monster ASCII frame (Digimon sprite sheet cell). */
+export declare const MONSTER_FRAME_COLUMNS = 16;

package/dist/digital-pet-animation/constants/presentation-timing.d.ts

@@ -0,0 +1,19 @@
+/** Sidebar monster animation tick interval. */
+export declare const SIDEBAR_VISUAL_INTERVAL_MS = 500;
+/** Idle time before the partner enters the sleep animation. */
+export declare const MONSTER_SLEEP_AFTER_MS = 300000;
+/** Pause before the evolution reveal sequence starts. */
+export declare const EVOLUTION_PRE_ANIMATION_MS = 400;
+export declare const EVOLUTION_GLOW_MS = 700;
+export declare const EVOLUTION_MORPH_MS = 1300;
+export declare const EVOLUTION_REVEAL_MS = 1500;
+export declare const EVOLUTION_TICK_MS = 70;
+export declare const EVOLUTION_BATTLE_INTRO_MS = 1600;
+export declare const EVOLUTION_BATTLE_TRAVEL_MS = 900;
+export declare const EVOLUTION_BATTLE_PAUSE_MS = 550;
+export declare const EVOLUTION_BATTLE_IMPACT_MS = 650;
+export declare const EVOLUTION_BATTLE_OUTCOME_MS = 1400;
+export declare const EVOLUTION_BATTLE_TICK_MS = 70;
+export declare const DEFEAT_CYCLE_MS = 550;
+export declare const DEFEAT_CYCLES = 5;
+export declare const DEFEAT_PRE_ANIMATION_MS = 300;

package/dist/digital-pet-animation/idle/monster-action-policy.d.ts

@@ -0,0 +1,7 @@
+import type { MonsterFrameCatalog, MonsterFrameName } from "../../digital-pet-core/data/monster-frame-catalog.js";
+export type CosmeticActionClip = readonly [MonsterFrameName, MonsterFrameName];
+export type SleepClip = readonly [MonsterFrameName, MonsterFrameName];
+export declare const resolveCosmeticActions: (sprite: string, catalog: MonsterFrameCatalog) => readonly CosmeticActionClip[];
+export declare const selectCosmeticAction: (actions: readonly CosmeticActionClip[], random: () => number) => CosmeticActionClip | undefined;
+export declare const resolveEatClip: (sprite: string, catalog: MonsterFrameCatalog) => CosmeticActionClip | undefined;
+export declare const resolveSleepClip: (sprite: string, fallback: MonsterFrameName, catalog: MonsterFrameCatalog) => SleepClip;

package/dist/digital-pet-animation/idle/monster-animation.d.ts

@@ -0,0 +1,73 @@
+import type { MonsterFrame, MonsterFrameCatalog } from "../../digital-pet-core/data/monster-frame-catalog.js";
+import { type WalkingFacing } from "./monster-walking-policy.js";
+export type MonsterAnimationIdentity = {
+    readonly sprite: string;
+    readonly isDigitama: boolean;
+};
+export type MonsterAnimationEvent = {
+    readonly kind: "partner_changed";
+    readonly partner: MonsterAnimationIdentity | undefined;
+} | {
+    readonly kind: "tick";
+} | {
+    readonly kind: "activity";
+} | {
+    readonly kind: "feed";
+} | {
+    readonly kind: "viewport_resized";
+    readonly width: number;
+};
+export type MonsterAnimationResult = {
+    readonly kind: "blank";
+} | {
+    readonly kind: "frame";
+    readonly frame: MonsterFrame;
+} | {
+    readonly kind: "unavailable";
+    readonly sprite: string;
+};
+export type MonsterFacing = WalkingFacing;
+type PositionedOutput = {
+    readonly offset: number;
+    readonly facing: MonsterFacing;
+};
+export type MonsterAnimationOutput = ({
+    readonly kind: "blank";
+    readonly result: {
+        readonly kind: "blank";
+    };
+} & PositionedOutput) | ({
+    readonly kind: "unavailable";
+    readonly result: {
+        readonly kind: "unavailable";
+        readonly sprite: string;
+    };
+} & PositionedOutput) | ({
+    readonly kind: "digitama";
+    readonly result: {
+        readonly kind: "frame";
+        readonly frame: MonsterFrame;
+    };
+} & PositionedOutput) | ({
+    readonly kind: "walking";
+    readonly result: {
+        readonly kind: "frame";
+        readonly frame: MonsterFrame;
+    };
+} & PositionedOutput) | ({
+    readonly kind: "action" | "sleeping";
+    readonly result: {
+        readonly kind: "frame";
+        readonly frame: MonsterFrame;
+    };
+} & PositionedOutput);
+export declare class MonsterAnimationController {
+    #private;
+    constructor(catalog: MonsterFrameCatalog, random?: () => number, nowMs?: () => number);
+    dispatch(event: MonsterAnimationEvent): MonsterAnimationOutput;
+    output(): MonsterAnimationOutput;
+    setSprite(sprite: string | undefined): void;
+    advance(): void;
+    get(): MonsterAnimationResult;
+}
+export {};

package/dist/digital-pet-animation/idle/monster-artwork-mirror.d.ts

@@ -0,0 +1,22 @@
+import { MonsterFrame } from "../../digital-pet-core/data/monster-frame-catalog.js";
+export type MalformedMonsterFrameReason = {
+    readonly kind: "row_count";
+    readonly actual: number;
+} | {
+    readonly kind: "column_count";
+    readonly row: number;
+    readonly actual: number;
+};
+export declare class MalformedMonsterFrameError extends Error {
+    readonly reason: MalformedMonsterFrameReason;
+    readonly name = "MalformedMonsterFrameError";
+    constructor(reason: MalformedMonsterFrameReason);
+}
+export type MirrorMonsterFrameResult = {
+    readonly kind: "mirrored";
+    readonly frame: MonsterFrame;
+} | {
+    readonly kind: "invalid";
+    readonly error: MalformedMonsterFrameError;
+};
+export declare const mirrorMonsterFrame: (frame: MonsterFrame) => MirrorMonsterFrameResult;

package/dist/digital-pet-animation/idle/monster-walking-policy.d.ts

@@ -0,0 +1,42 @@
+import type { MonsterFrameCatalog, MonsterFrameName } from "../../digital-pet-core/data/monster-frame-catalog.js";
+export type WalkingFacing = "left" | "right";
+export type WalkFrame = "walk_1" | "walk_2";
+type MovementBounds = {
+    readonly left: number;
+    readonly right: number;
+};
+type WalkingBout = {
+    readonly kind: "suspended";
+} | {
+    readonly kind: "moving";
+    readonly remaining: number;
+} | {
+    readonly kind: "boundary_hold" | "queued_action";
+};
+export type WalkingPolicyState = {
+    readonly frameName: WalkFrame;
+    readonly offset: number;
+    readonly facing: WalkingFacing;
+    readonly bounds: MovementBounds | undefined;
+    readonly bout: WalkingBout;
+};
+export type ActionBoundaryState = {
+    readonly frameName: MonsterFrameName;
+    readonly offset: number;
+    readonly facing: WalkingFacing;
+    readonly bounds: MovementBounds | undefined;
+};
+export type WalkingPolicyTick = {
+    readonly kind: "walking";
+    readonly walking: WalkingPolicyState;
+} | {
+    readonly kind: "action";
+    readonly action: ActionBoundaryState;
+};
+export declare const initialWalkingPolicy: (frameName: WalkFrame) => WalkingPolicyState;
+export declare const tickWalkingPolicy: (state: WalkingPolicyState, sprite: string, catalog: MonsterFrameCatalog) => WalkingPolicyTick;
+export declare const resizeWalkingPolicy: (state: WalkingPolicyState, width: number, random: () => number) => WalkingPolicyState;
+export declare const resizeActionBoundary: (state: ActionBoundaryState, width: number) => ActionBoundaryState;
+export declare const resumeWalkingPolicy: (state: ActionBoundaryState, random: () => number) => WalkingPolicyState;
+export declare const restartWalkingPolicy: (state: ActionBoundaryState, frameName: WalkFrame, random: () => number) => WalkingPolicyState;
+export {};

package/dist/digital-pet-animation/render/positioned-artwork.d.ts

@@ -0,0 +1,3 @@
+import type { MonsterAnimationOutput, MonsterAnimationResult } from "../idle/monster-animation.js";
+export declare const renderPositionedArtworkRows: (animation: MonsterAnimationOutput | MonsterAnimationResult, viewportWidth: number) => readonly string[];
+export declare const renderPositionedArtwork: (animation: MonsterAnimationOutput | MonsterAnimationResult, viewportWidth: number) => string;

package/dist/digital-pet-animation/sequences/defeat-artwork.d.ts

@@ -0,0 +1,7 @@
+import type { MonsterFrameCatalog } from "../../digital-pet-core/data/monster-frame-catalog.js";
+export type DefeatArtworkScene = {
+    readonly sad: boolean;
+    readonly sadAlt: boolean;
+};
+export declare const renderDefeatArtwork: (catalog: MonsterFrameCatalog, sprite: string, scene: DefeatArtworkScene, viewportWidth: number) => string;
+export declare const runDefeatAnimation: (catalog: MonsterFrameCatalog, sprite: string, viewportWidth: number, onFrame: (artwork: string) => Promise<void>) => Promise<void>;

package/dist/digital-pet-animation/sequences/evolution-artwork.d.ts

@@ -0,0 +1,8 @@
+import type { MonsterFrameCatalog } from "../../digital-pet-core/data/monster-frame-catalog.js";
+export type EvolutionArtworkPhase = "glow" | "morph" | "reveal";
+export type EvolutionArtworkScene = {
+    readonly phase: EvolutionArtworkPhase;
+    readonly progress: number;
+};
+export declare const renderEvolutionArtwork: (catalog: MonsterFrameCatalog, fromSprite: string, toSprite: string, scene: EvolutionArtworkScene, viewportWidth: number, tick?: number) => string;
+export declare const runEvolutionAnimation: (catalog: MonsterFrameCatalog, fromSprite: string, toSprite: string, viewportWidth: number, onFrame: (artwork: string) => Promise<void>) => Promise<void>;

package/dist/digital-pet-animation/sequences/evolution-battle-artwork.d.ts

@@ -0,0 +1,33 @@
+import type { MonsterFrameCatalog } from "../../digital-pet-core/data/monster-frame-catalog.js";
+/** FIGlet-style BATTLE banner. */
+export declare const BATTLE_FIGLET_LINES: readonly string[];
+export declare const buildBattleIntroTextLines: () => readonly string[];
+/** Block-style flame sprite matching Digimon ASCII art. */
+export declare const FIREBALL_LINES: readonly string[];
+export type EvolutionBattleShooter = "player" | "opponent";
+export type EvolutionBattleOutcome = EvolutionBattleShooter;
+export type BattleSpritePose = "attack" | "injured" | "happy" | "idle";
+export type EvolutionBattleResultLabel = "hit" | "miss" | null;
+export type EvolutionBattleShot = {
+    readonly shooter: EvolutionBattleShooter;
+    readonly hit: boolean;
+};
+export type EvolutionBattleScene = {
+    readonly shooter: EvolutionBattleShooter | null;
+    readonly progress: number;
+    readonly playerPose: BattleSpritePose;
+    readonly opponentPose: BattleSpritePose;
+    readonly playerInjuredAlt: boolean;
+    readonly opponentInjuredAlt: boolean;
+    readonly playerHits: number;
+    readonly opponentHits: number;
+    readonly lastResult: EvolutionBattleResultLabel;
+    readonly outcomeLabel: string | null;
+};
+export declare const buildBattleScorePips: (hits: number, total?: number) => string;
+export declare const buildBattleScoreRow: (playerHits: number, opponentHits: number, width?: number) => string;
+export declare const planEvolutionBattle: (outcome: EvolutionBattleOutcome, random?: () => number) => readonly EvolutionBattleShot[];
+export declare const defaultBattleScene: (overrides?: Partial<EvolutionBattleScene>) => EvolutionBattleScene;
+export declare const renderBattleIntroArtwork: (viewportWidth: number, _progress: number, tick?: number) => string;
+export declare const renderEvolutionBattleArtwork: (catalog: MonsterFrameCatalog, playerSprite: string, opponentSprite: string, scene: EvolutionBattleScene, viewportWidth: number) => string;
+export declare const runEvolutionBattleAnimation: (catalog: MonsterFrameCatalog, playerSprite: string, opponentSprite: string, viewportWidth: number, outcome: EvolutionBattleOutcome, onFrame: (artwork: string) => Promise<void>, random?: () => number) => Promise<EvolutionBattleOutcome>;

package/dist/digital-pet-animation/sessions/evolution-battle-session.d.ts

@@ -0,0 +1,14 @@
+import type { ResolveEvolutionBattleOutcome } from "../../digital-pet-core/application/models/usage.js";
+import type { SidebarSnapshot } from "../../digital-pet-core/application/ports/sidebar-snapshot.js";
+import { type EvolutionBattleRepository } from "../../digital-pet-core/application/use-cases/resolve-evolution-battle.js";
+import type { DigimonCatalog } from "../../digital-pet-core/data/catalog.js";
+import type { MonsterFrameCatalog } from "../../digital-pet-core/data/monster-frame-catalog.js";
+export type EvolutionBattleSessionDependencies = {
+    readonly frameCatalog: MonsterFrameCatalog;
+    readonly digimonCatalog: DigimonCatalog;
+    readonly repository: EvolutionBattleRepository;
+    readonly random?: () => number;
+    readonly onArtwork: (artwork: string) => Promise<void>;
+    readonly onResolved?: (result: ResolveEvolutionBattleOutcome) => Promise<void>;
+};
+export declare const runEvolutionBattleSession: (snapshot: SidebarSnapshot, viewportWidth: number, dependencies: EvolutionBattleSessionDependencies) => Promise<boolean>;

package/dist/digital-pet-animation/sessions/evolution-reveal-session.d.ts

@@ -0,0 +1,9 @@
+import type { UsageEvolutionTransition } from "../../digital-pet-core/application/models/usage.js";
+import type { DigimonCatalog } from "../../digital-pet-core/data/catalog.js";
+import type { MonsterFrameCatalog } from "../../digital-pet-core/data/monster-frame-catalog.js";
+export type EvolutionRevealSessionDependencies = {
+    readonly frameCatalog: MonsterFrameCatalog;
+    readonly digimonCatalog: DigimonCatalog;
+    readonly onArtwork: (artwork: string) => Promise<void>;
+};
+export declare const runEvolutionRevealSession: (evolution: UsageEvolutionTransition, viewportWidth: number, dependencies: EvolutionRevealSessionDependencies) => Promise<boolean>;

package/dist/digital-pet-animation/utils/assert-never.d.ts

@@ -0,0 +1 @@
+export declare const assertNever: (value: never) => never;

package/dist/digital-pet-animation/utils/random.d.ts

@@ -0,0 +1,2 @@
+/** Returns value in [0, 1) safe for index selection. */
+export declare const normalizedRandom: (random: () => number) => number;

package/dist/digital-pet-animation/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/digital-pet-core/adapters/sqlite/app-data-path.d.ts

@@ -0,0 +1,5 @@
+export type HostPathOptions = {
+    readonly appDataRoot?: string;
+};
+export declare const resolveHostDataDirectory: (options?: HostPathOptions) => string;
+export declare const resolveHostDatabasePath: (options?: HostPathOptions) => string;

package/dist/digital-pet-core/adapters/sqlite/sqlite-digital-pet-schema.d.ts

@@ -0,0 +1,48 @@
+import type { Partner } from "../../domain/partner.js";
+import type { PersistedPartnerEvent, PersistedPartnerEventKind, UsageReceiptRecord } from "./sqlite-digital-pet-types.js";
+export type PersistedPartnerRow = {
+    readonly partner_id: string;
+    readonly generation: number;
+    readonly current_node_id: string;
+    readonly gauge: number;
+    readonly is_terminal: number;
+    readonly pending_evolution_target_id: string | null;
+    readonly battle_opponent_node_id: string | null;
+    readonly created_at: string;
+    readonly retired_at: string | null;
+};
+export type PersistedPartnerEventRow = {
+    readonly event_id: string;
+    readonly partner_id: string;
+    readonly kind: PersistedPartnerEventKind;
+    readonly current_node_id: string;
+    readonly gauge: number;
+    readonly is_terminal: number;
+    readonly token_delta: number | null;
+    readonly receipt_key: string | null;
+    readonly created_at: string;
+};
+export type UsageReceiptRow = {
+    readonly receipt_key: string;
+    readonly partner_id: string;
+    readonly event_id: string;
+    readonly token_delta: number;
+    readonly cost: number | null;
+    readonly created_at: string;
+};
+export type TrainerStateRow = {
+    readonly total_tokens: number;
+};
+export type MigrationRow = {
+    readonly version: number;
+};
+export declare const ACTIVE_PARTNER_SELECT = "\n  SELECT\n    \n    partner_id,\n    generation,\n    current_node_id,\n    gauge,\n    is_terminal,\n    pending_evolution_target_id,\n    battle_opponent_node_id,\n    created_at,\n    retired_at\n\n  FROM partners\n  WHERE retired_at IS NULL\n  LIMIT 1\n";
+export declare const PARTNERS_SELECT = "\n  SELECT\n    \n    partner_id,\n    generation,\n    current_node_id,\n    gauge,\n    is_terminal,\n    pending_evolution_target_id,\n    battle_opponent_node_id,\n    created_at,\n    retired_at\n\n  FROM partners\n  ORDER BY generation ASC, created_at ASC, partner_id ASC\n";
+export declare const ARCHIVE_PARTNERS_SELECT = "\n  SELECT\n    \n    partner_id,\n    generation,\n    current_node_id,\n    gauge,\n    is_terminal,\n    pending_evolution_target_id,\n    battle_opponent_node_id,\n    created_at,\n    retired_at\n\n  FROM partners\n  ORDER BY partner_id ASC\n";
+export declare const PARTNER_BY_GENERATION_SELECT = "\n  SELECT\n    \n    partner_id,\n    generation,\n    current_node_id,\n    gauge,\n    is_terminal,\n    pending_evolution_target_id,\n    battle_opponent_node_id,\n    created_at,\n    retired_at\n\n  FROM partners\n  WHERE generation = ?\n  LIMIT 1\n";
+export declare const PARTNER_EVENTS_SELECT = "\n  SELECT\n    event_id,\n    partner_id,\n    kind,\n    current_node_id,\n    gauge,\n    is_terminal,\n    token_delta,\n    receipt_key,\n    created_at\n  FROM partner_events\n  WHERE partner_id = ?\n  ORDER BY created_at ASC, event_id ASC\n";
+export declare const ARCHIVE_PARTNER_EVENTS_SELECT = "\n  SELECT\n    event_id,\n    partner_id,\n    kind,\n    current_node_id,\n    gauge,\n    is_terminal,\n    token_delta,\n    receipt_key,\n    created_at\n  FROM partner_events\n  ORDER BY partner_id ASC, created_at ASC, event_id ASC\n";
+export declare const USAGE_RECEIPTS_SELECT = "\n  SELECT receipt_key, partner_id, event_id, token_delta, cost, created_at\n  FROM usage_receipts\n  ORDER BY created_at ASC, receipt_key ASC\n";
+export declare const toPartner: (row: PersistedPartnerRow) => Partner;
+export declare const toPersistedPartnerEvent: (row: PersistedPartnerEventRow) => PersistedPartnerEvent;
+export declare const toUsageReceiptRecord: (row: UsageReceiptRow) => UsageReceiptRecord;

package/dist/digital-pet-core/adapters/sqlite/sqlite-digital-pet-types.d.ts

@@ -0,0 +1,43 @@
+import type { Partner, PartnerProgression } from "../../domain/partner.js";
+import type { SpawnPartnerInput } from "../../application/models/spawn-partner.js";
+import type { ApplyUsageReceiptOutcome, ResolveEvolutionBattleOutcome, UsageReceiptMetadata } from "../../application/models/usage.js";
+import type { PartnerLifecycle } from "../../application/ports/partner-lifecycle.js";
+import type { UsageLedger } from "../../application/ports/usage-ledger.js";
+import type { DigitalPetControl } from "../../application/ports/digital-pet-control.js";
+export type PersistedPartner = Partner;
+export type PersistedPartnerEventKind = "spawned" | "usage_applied" | "retired";
+export type PersistedPartnerEvent = {
+    readonly eventId: string;
+    readonly partnerId: string;
+    readonly kind: PersistedPartnerEventKind;
+    readonly currentNodeId: string;
+    readonly gauge: number;
+    readonly isTerminal: boolean;
+    readonly tokenDelta: number | null;
+    readonly receiptKey: string | null;
+    readonly createdAt: string;
+};
+export type UsageReceiptRecord = {
+    readonly receiptKey: string;
+    readonly partnerId: string;
+    readonly eventId: string;
+    readonly tokenDelta: number;
+    readonly createdAt: string;
+};
+export type TrainerState = {
+    readonly totalTokens: number;
+};
+export type PersistedPartnerSummary = Partner;
+export type SqliteDigitalPetWriteStore = PartnerLifecycle & UsageLedger & DigitalPetControl & {
+    close: () => Promise<void>;
+    readonly databasePath: string;
+    getAppliedMigrations: () => readonly number[];
+    getTrainerState: () => TrainerState;
+    getActivePartner: () => PersistedPartner | null;
+    listPartners: () => readonly PersistedPartnerSummary[];
+    getPartnerByGeneration: (generation: number) => PersistedPartnerSummary | null;
+    listPartnerEvents: (partnerId: string) => readonly PersistedPartnerEvent[];
+    listUsageReceipts: () => readonly UsageReceiptRecord[];
+    resolveEvolutionBattle: (nextState: PartnerProgression, createdAt: string) => ResolveEvolutionBattleOutcome;
+};
+export type { ApplyUsageReceiptOutcome, PartnerProgression, SpawnPartnerInput, UsageReceiptMetadata };

package/dist/digital-pet-core/adapters/sqlite/sqlite-digital-pet-write-store.d.ts

@@ -0,0 +1,8 @@
+import type { SqliteExecutor } from "../../ports/sqlite-executor.js";
+import type { SqliteDigitalPetWriteStore } from "./sqlite-digital-pet-types.js";
+export type CreateSqliteDigitalPetWriteStoreOptions = {
+    readonly databasePath: string;
+    readonly executor: SqliteExecutor;
+    readonly close: () => Promise<void> | void;
+};
+export declare const createSqliteDigitalPetWriteStore: (options: CreateSqliteDigitalPetWriteStoreOptions) => SqliteDigitalPetWriteStore;

package/dist/digital-pet-core/adapters/sqlite/sqlite-migrations.d.ts

@@ -0,0 +1,4 @@
+import type { SqliteExecutor } from "../../ports/sqlite-executor.js";
+type SqliteMigrationExecutor = Pick<SqliteExecutor, "run" | "all" | "transaction">;
+export declare const runMigrations: (database: SqliteMigrationExecutor) => readonly number[];
+export {};

package/dist/digital-pet-core/application/models/digital-pet-archive.d.ts

@@ -0,0 +1,21 @@
+export type DigitalPetArchiveEvent = {
+    readonly eventId: string;
+    readonly currentNodeId: string;
+    readonly createdAt: string;
+};
+export type DigitalPetArchivePartner = {
+    readonly partnerId: string;
+    readonly generation: number;
+    readonly createdAt: string;
+    readonly retiredAt: string | null;
+    readonly events: readonly DigitalPetArchiveEvent[];
+};
+export type DigitalPetArchiveResult = {
+    readonly kind: "available";
+    readonly partners: readonly DigitalPetArchivePartner[];
+} | {
+    readonly kind: "empty";
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};

package/dist/digital-pet-core/application/models/digital-pet-control.d.ts

@@ -0,0 +1,17 @@
+export type FreezeDigitalPetOutcome = {
+    readonly kind: "frozen";
+} | {
+    readonly kind: "already_frozen";
+};
+export type UnfreezeDigitalPetOutcome = {
+    readonly kind: "unfrozen";
+} | {
+    readonly kind: "already_unfrozen";
+};
+export type SetCheatNodeOutcome = {
+    readonly kind: "set";
+    readonly cheatNodeId: string;
+} | {
+    readonly kind: "already_set";
+    readonly cheatNodeId: string;
+};

package/dist/digital-pet-core/application/models/sidebar-card-inputs.d.ts

@@ -0,0 +1,13 @@
+import type { DigimonNode } from "../../domain/digimon-node.js";
+export type SidebarCardInputs = {
+    readonly kind: "no_partner";
+} | {
+    readonly kind: "partner";
+    readonly node: DigimonNode;
+    readonly gauge: number;
+    readonly isTerminal: boolean;
+    readonly frozen: boolean;
+    readonly isSetOverride: boolean;
+    readonly trainerTotalTokens: number;
+    readonly evolutionBattlePending: boolean;
+};

package/dist/digital-pet-core/application/models/spawn-partner.d.ts

@@ -0,0 +1,9 @@
+export type SpawnPartnerInput = {
+    readonly currentNodeId: string;
+    readonly gauge: number;
+    readonly isTerminal: boolean;
+    readonly createdAt: string;
+};
+export type SpawnPartnerResult = {
+    readonly generation: number;
+};

package/dist/digital-pet-core/application/models/usage.d.ts

@@ -0,0 +1,42 @@
+export type UsageReceiptMetadata = {
+    readonly receiptKey: string;
+    readonly eventId: string;
+    readonly tokenDelta: number;
+    readonly cost?: number | null;
+    readonly createdAt: string;
+};
+export type ApplyUsageReceiptOutcome = {
+    readonly kind: "applied";
+} | {
+    readonly kind: "duplicate";
+} | {
+    readonly kind: "no_active_partner";
+};
+export type UsageEvolutionTransition = {
+    readonly fromNodeId: string;
+    readonly toNodeId: string;
+};
+export type EvolutionBattlePending = {
+    readonly opponentNodeId: string;
+    readonly targetNodeId: string;
+};
+export type UsageProcessingResult = {
+    readonly kind: "applied";
+    readonly receiptKey: string;
+    readonly evolution?: UsageEvolutionTransition;
+    readonly evolutionBattlePending?: EvolutionBattlePending;
+} | {
+    readonly kind: "duplicate";
+    readonly receiptKey: string;
+} | {
+    readonly kind: "no_active_partner";
+    readonly receiptKey: string;
+};
+export type ResolveEvolutionBattleOutcome = {
+    readonly kind: "won";
+    readonly evolution: UsageEvolutionTransition;
+} | {
+    readonly kind: "lost";
+} | {
+    readonly kind: "no_pending_battle";
+};

package/dist/digital-pet-core/application/ports/digital-pet-archive.d.ts

@@ -0,0 +1,4 @@
+import type { DigitalPetArchiveResult } from "../models/digital-pet-archive.js";
+export type DigitalPetArchiveReader = {
+    getArchive: () => DigitalPetArchiveResult;
+};

package/dist/digital-pet-core/application/ports/digital-pet-control.d.ts

@@ -0,0 +1,6 @@
+import type { FreezeDigitalPetOutcome, SetCheatNodeOutcome, UnfreezeDigitalPetOutcome } from "../models/digital-pet-control.js";
+export type DigitalPetControl = {
+    freeze: () => FreezeDigitalPetOutcome;
+    unfreeze: () => UnfreezeDigitalPetOutcome;
+    setCheatNode: (validatedNodeId: string) => SetCheatNodeOutcome;
+};

package/dist/digital-pet-core/application/ports/partner-lifecycle.d.ts

@@ -0,0 +1,5 @@
+import type { Partner } from "../../domain/partner.js";
+import type { SpawnPartnerInput } from "../models/spawn-partner.js";
+export type PartnerLifecycle = {
+    spawnPartner: (input: SpawnPartnerInput) => Partner;
+};

package/dist/digital-pet-core/application/ports/sidebar-snapshot.d.ts

@@ -0,0 +1,13 @@
+export type SidebarSnapshot = {
+    readonly currentNodeId: string;
+    readonly gauge: number;
+    readonly isTerminal: boolean;
+    readonly frozen: boolean;
+    readonly isSetOverride: boolean;
+    readonly trainerTotalTokens: number;
+    readonly pendingEvolutionTargetId: string | null;
+    readonly battleOpponentNodeId: string | null;
+};
+export type SidebarSnapshotReader = {
+    getSidebarSnapshot: () => SidebarSnapshot | null;
+};

package/dist/digital-pet-core/application/ports/usage-ledger.d.ts

@@ -0,0 +1,5 @@
+import type { Partner, PartnerProgression } from "../../domain/partner.js";
+import type { ApplyUsageReceiptOutcome, UsageReceiptMetadata } from "../models/usage.js";
+export type UsageLedger = {
+    applyUsageReceipt: (metadata: UsageReceiptMetadata, evolve: (partner: Partner) => PartnerProgression) => ApplyUsageReceiptOutcome;
+};

package/dist/digital-pet-core/application/use-cases/freeze-digital-pet.d.ts

@@ -0,0 +1,3 @@
+import type { FreezeDigitalPetOutcome } from "../models/digital-pet-control.js";
+import type { DigitalPetControl } from "../ports/digital-pet-control.js";
+export declare const freezeDigitalPet: (control: Pick<DigitalPetControl, "freeze">) => FreezeDigitalPetOutcome;

package/dist/digital-pet-core/application/use-cases/get-sidebar-card-inputs.d.ts

@@ -0,0 +1,4 @@
+import type { DigimonCatalog } from "../../domain/digimon-node.js";
+import type { SidebarCardInputs } from "../models/sidebar-card-inputs.js";
+import type { SidebarSnapshotReader } from "../ports/sidebar-snapshot.js";
+export declare const getSidebarCardInputs: (reader: SidebarSnapshotReader, catalog: DigimonCatalog) => SidebarCardInputs;

package/dist/digital-pet-core/application/use-cases/reconcile-usage.d.ts

@@ -0,0 +1,14 @@
+import type { DigimonNode } from "../../domain/digimon-node.js";
+import type { EvolutionSelector, StageThresholds } from "../../domain/evolution.js";
+import type { UsageProcessingResult } from "../models/usage.js";
+import type { UsageLedger } from "../ports/usage-ledger.js";
+import { type CompletedUsage } from "./record-usage.js";
+export type ReconcileUsageInput = {
+    readonly usages: readonly CompletedUsage[];
+    readonly ledger: UsageLedger;
+    readonly digimonById: ReadonlyMap<string, DigimonNode>;
+    readonly catalogNodes: readonly DigimonNode[];
+    readonly selector: EvolutionSelector;
+    readonly thresholds: StageThresholds;
+};
+export declare const reconcileUsage: ({ usages, ledger, digimonById, catalogNodes, selector, thresholds, }: ReconcileUsageInput) => readonly UsageProcessingResult[];

package/dist/digital-pet-core/application/use-cases/record-usage.d.ts

@@ -0,0 +1,14 @@
+import type { DigimonNode } from "../../domain/digimon-node.js";
+import { type EvolutionSelector, type StageThresholds } from "../../domain/evolution.js";
+import type { UsageProcessingResult, UsageReceiptMetadata } from "../models/usage.js";
+import type { UsageLedger } from "../ports/usage-ledger.js";
+export type CompletedUsage = UsageReceiptMetadata;
+export type RecordUsageInput = {
+    readonly usage: CompletedUsage;
+    readonly ledger: UsageLedger;
+    readonly digimonById: ReadonlyMap<string, DigimonNode>;
+    readonly catalogNodes: readonly DigimonNode[];
+    readonly selector: EvolutionSelector;
+    readonly thresholds: StageThresholds;
+};
+export declare const recordUsage: ({ usage, ledger, digimonById, catalogNodes, selector, thresholds, }: RecordUsageInput) => UsageProcessingResult;

package/dist/digital-pet-core/application/use-cases/resolve-evolution-battle.d.ts

@@ -0,0 +1,8 @@
+import type { DigimonNode } from "../../domain/digimon-node.js";
+import type { Partner } from "../../domain/partner.js";
+import type { ResolveEvolutionBattleOutcome } from "../models/usage.js";
+export type EvolutionBattleRepository = {
+    getActivePartner: () => Partner | null;
+    resolveEvolutionBattle: (nextState: import("../../domain/partner.js").PartnerProgression, createdAt: string) => ResolveEvolutionBattleOutcome;
+};
+export declare const resolveEvolutionBattleForPartner: (repository: EvolutionBattleRepository, won: boolean, digimonById: ReadonlyMap<string, DigimonNode>, createdAt: string) => ResolveEvolutionBattleOutcome;

package/dist/digital-pet-core/application/use-cases/set-digital-pet-cheat-node.d.ts

@@ -0,0 +1,3 @@
+import type { SetCheatNodeOutcome } from "../models/digital-pet-control.js";
+import type { DigitalPetControl } from "../ports/digital-pet-control.js";
+export declare const setDigitalPetCheatNode: (control: Pick<DigitalPetControl, "setCheatNode">, validatedNodeId: string) => SetCheatNodeOutcome;

package/dist/digital-pet-core/application/use-cases/spawn-partner.d.ts

@@ -0,0 +1,3 @@
+import type { PartnerLifecycle } from "../ports/partner-lifecycle.js";
+import type { SpawnPartnerResult } from "../models/spawn-partner.js";
+export declare const spawnPartner: (lifecycle: PartnerLifecycle, createdAt: string) => SpawnPartnerResult;

package/dist/digital-pet-core/application/use-cases/unfreeze-digital-pet.d.ts

@@ -0,0 +1,3 @@
+import type { UnfreezeDigitalPetOutcome } from "../models/digital-pet-control.js";
+import type { DigitalPetControl } from "../ports/digital-pet-control.js";
+export declare const unfreezeDigitalPet: (control: Pick<DigitalPetControl, "unfreeze">) => UnfreezeDigitalPetOutcome;